* STEP import: mesh band faces that wrap around a closed surface correctly Fixes two related bugs that caused SolidCraft to fail to mesh a face wrapping all the way around a closed, non-periodic surface (a revolved ridge band, or a tube-shaped B-spline surface): a missing face, a folded/self-overlapping triangulation, or a hole in the rendered body. 1. Ring edges that run slightly off their surface. STEP files write a surface and the curves bounding it to the file's own declared uncertainty, so a ring edge can legitimately sit a few micrometres off the surface it bounds. The code finding where a ring edge crosses the planned split line compared against the edge's raw (off-surface) point using a hardcoded tolerance far stricter than the file's own precision, rejecting a valid cut. Now matches against the point on the surface directly below the ring crossing, respecting the file's declared tolerance. 2. Closed B-spline surfaces, their slits and their slivers. truck only treats the rotation of a revolved surface as periodic; a face on a B-spline surface whose control net closes on itself (a tube) wasn't recognized as wrapping around at all. This produced a folded face, a hole (a boundary loop landing a full period away from where it should cut), and one near-zero-width sliver face costing the entire body its tessellation plan. Adds periodicity detection for closed B-spline surfaces, period- aware hole-loop alignment, dropping of zero-width slit boundaries, and isolating a too-thin-to-triangulate face so it no longer takes the rest of the body down with it. The GPU shader's periodic wrap mirrors the CPU math so the two don't drift apart. Regression tests: band_faces_split_when_ring_edges_run_off_their_surface, band_face_with_a_zero_width_slit_is_still_meshed, a_sliver_face_too_thin_to_triangulate_does_not_cost_the_body_its_plan. Ablation-tested: disabling either mechanism in (2) reproduces its target test's original failure message while leaving the other test unaffected. * STEP import: mesh the band's split faces, not just split them jyviko asked whether a band wall missing from the interactive app's render was a shading issue or a genuinely missing face. It was missing: the ring- edge split fix made the band's topology correct, but plan_face still produced zero triangles for the two new sub-faces. Two causes, both in plan_face (crates/kernel/src/tess/mod.rs): 1. The tolerance for how far an imported boundary may lie off its surface was tied to the requested mesh's chord tolerance instead of to the body's own size. A finer display tolerance could then reject a boundary a coarser one had just accepted, so the face would drop out exactly when zooming in on it. 2. Near a sharp corner of this flat-panelled band, several boundary points that are legitimately a few micrometres apart (within the STEP file's own declared precision) all projected onto the same surface point. The boundary loop then repeated a point in (u, v), which a triangulator can't follow, so the face's plan failed outright. One face without a plan costs the whole body its plan, and the fallback mesher can't handle a closed B-spline surface either, leaving both halves of the split band with no triangles at all: present in the topology, invisible in every renderer, and absent from the body's volume. Fix: scale the off-surface tolerance to the body's own extent (new Rules::extent), and collapse a run of boundary nodes that land on the same surface point to one (drop_collapsed) before triangulating. Regression test additions to band_faces_split_when_ring_edges_run_off_their_surface: the body's volume now matches the analytic pentagon prism (was a third of it - only the top cap - before this fix); display_plan leaves no face without triangles from coarse to fine tolerance; and the actual tolerance and facet angle the viewport draws with gives the split band its full lateral area on both halves. Confirmed on review_band_big.step, the fixture behind the review screenshots: volume's relative error against the analytic pentagon prism drops from 1.4e-4 to 4.1e-6, and the band wall now occludes the floor grid behind it in a snapshot the same way the top and bottom caps always did. Full kernel suite: 739 tests, 0 failed. * STEP import: hold an imported boundary to the file's own tolerance, not the part's size jyviko: the off-surface acceptance added in the last commit (rules.extent * OFF_SURFACE) scaled with the part, so a 2 m part silently accepted a boundary 2 mm off its surface while a 20 mm copy of the same part accepted only 0.02 mm. A STEP file's own declared uncertainty does not grow with the part, so the bound shouldn't either. Body gains boundary_tol: Option<f64>, Some(file's declared tolerance) for a body read from STEP (crate::step_in::Units::tol, already used by the ring-split fix in split.rs), None for anything this kernel built. It's set before the import's own unmeshed-face check runs, and carried over by the two face-split operations that re-cut an imported surface (splitface.rs, outline.rs), since the file's uncertainty still describes those boundaries afterward. plan_face's accept now reads: the file's own tolerance when the body declares one, or the old chord-tolerance/extent bound otherwise. The old bound's tol * 10.0 term had to go too, not just the extent term: at a 2 m part's typical display tolerance that term alone is ~20 mm, nearly ten times the extent bound jyviko objected to, so keeping it would have left the exact 2 m/2 mm example still silently accepted. Two new tests in step_in/tests.rs: - band_faces_split_when_a_scaled_copy_runs_off_its_surface: the same band fixture at a realistic 2 m scale with the same absolute slop and declared uncertainty as the small one, meshes the same way at every chord tolerance from coarse to fine. - off_surface_budget_follows_the_file_not_the_part_size: the actual regression. The same off-surface error is accepted or refused the same way whether the part is 20 mm or 2 m; a 2 mm error against a 1 µm declared uncertainty is refused at both sizes now (accepted at 2 m under the old bound, refused at 20 mm - that asymmetry was the bug). Checked at both a coarse and a fine display tolerance. Known gap, not fixed here: a STEP-imported body saved into a .solidcraft design and reopened loses boundary_tol (native.rs's decoder has no field to read it from) and falls back to the old extent-based bound on reload. Today's design format has no concept of this value at all; persisting it is a real format change, out of scope for this fix. Full kernel suite: 776 tests, 0 failed. clippy -D warnings clean. * Display plans for STEP threads and pointed ends (#3847) Three faces cost a threaded or pointed STEP part its whole display plan, so it was drawn from the reference mesh: cracked, faceted, and never refined up close. - A loop through a pole (a cone's apex on the boundary) seemed to wind around the surface: the jump at the apex, unwrapped to the nearest copy, was arbitrary. The loop is turned to end where it leaves the pole, so the step that closes it is an ordinary one (`seam::close_through_pole`). - Projection onto a spline with hundreds of spans (a helical flank) restarted from a 16 x 16 grid and settled on another turn; it now starts from two points per span, capped. - Sag refinement no longer inserts a point exactly on a boundary side, which split the side and failed the face. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * tess: a refused face's edges are divided finer and it is planned again (#2814) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM * tess: sliver faces plan empty; a face no method plans is filled flat from its nodes (#2814) A face whose boundary runs out and back along itself (two edges between the same vertices, a rounding apart, as STEP files write slivers) encloses nothing and is planned with no triangles. A face still refused after its edges are divided finer (a cusp, a sliver whose sides sag across each other, a small cap at a pole) is filled flat from its shared boundary nodes, so the rest of the body keeps its display plan instead of falling back to the reference mesh. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM * display mesh tests: a rim the chord tolerance leaves a line is divided again (#2814) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM * portable B-rep: up to 8192 control points along a spline direction (#2814) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM * solidcraft-cli: --debug logs what the engine reports to stderr Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM * STEP import: a spline written over a tiny parameter range is read over one (#2814) Some writers parameterize splines over a few millionths (a humanoid robot's edges span 5.4e-6). The kernel tells parameters apart only to 1e-6, so over such a range it evaluated the curve's end wrongly, and trimming an edge to its vertices dropped a control point: the bodies could not be stored exactly and the whole model cache was left out of the design. The knots are now stretched to span one; the curve is the same and edges are trimmed by their vertices, so nothing read from the file refers to the old parameters. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM * model cache: a body keeps its file's declared accuracy (#2814) A body restored from the cache dropped the accuracy the file it was read from declares, so the planner held its boundaries to the kernel's own bound and a reopened design drew differently from the import. It is stored with the body's runtime values, and only when there is one. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM * tess: a boundary within a hundredth of its body lies on its surface, at every quality (#2814) #1721 held a body read from a file to the accuracy the file declares. A writer declares what it aims for, not a bound its edges keep: a 251-body robot assembly declaring 0.01 µm has boundaries 10 to 30 µm off their surfaces, and 95 of its bodies lost their display plans. The bound is a hundredth of the body again, what Normal quality always allowed, and now the same at every quality, so zooming in still never drops a face (#1721's point). A file declaring more raises it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM * STEP import: keep faces whose edge vertices sit slightly off their curves Some exporters write an edge's vertex beside the end of its curve, further off than the accuracy the file declares (a surface export declares 0.01 mm and puts a vertex 0.19 mm off two spline ends). The reader refused such edges and left the face, and with single-face bodies the body, out. A vertex may now sit up to the file's tolerance or 1/1000 of the model's size (the diagonal around its VERTEX_POINTs), whichever is larger, never more than the existing 1 mm ceiling. Spline and open-conic edges have the end control point moved onto the vertex, so every such edge meets its vertices exactly. The file's declared accuracy still governs closed-curve, seam and circle checks. * tess, io: review clean-ups (#2814) - A sliver face is one whose loops are all slit: drop_slits finds it in the retry after a failed plan, so the pre-check on every face (folded) is gone. - The flat fill uses cdt::triangulate (a lenient fill that leaves out sides crossing one already kept) and its flood-fill inside test, and the plane from geom::Plane. - Refinement only builds its indexes when a face was refused, takes the faces to plan again from edge_faces, and re-samples edges on the pool; Rules::finer for the finer rules. - One PackageWriter::fits for the model cache, the preview and the thumbnail. - The band split's ring tolerance lives in split.rs; comments say what the off-surface bound is now. - The CLI logger prints Level::as_str(). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LGeCa5jWWdroMWvXxN3LLM --------- Co-authored-by: David Lackovic <lackovicdavid1234@gmail.com> Co-authored-by: bherbruck <brennen.herbruck@gmail.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com> Co-authored-by: Ray <raykholo@users.noreply.github.com>
2002 lines
95 KiB
Rust
2002 lines
95 KiB
Rust
//! STEP (ISO 10303-21) export: AP242 product structure, assemblies, names and colours.
|
||
//!
|
||
//! Each body's B-rep is written by truck's STEP writer (geometry and topology only), read back
|
||
//! with our Part 21 parser and copied into a file we assemble ourselves: one header and
|
||
//! context, a product per part with its shape representation, named solids, surface colours,
|
||
//! and assemblies as next-assembly-usage occurrences placed by item-defined transformations
|
||
//! (the structure the CAx-IF recommends and our reader follows). Identical geometric entities
|
||
//! (points, directions, placements, curves, surfaces) are written once and referenced; ids are
|
||
//! dense from `#1`.
|
||
|
||
use std::collections::HashMap;
|
||
use std::fmt::Write as _;
|
||
|
||
use solidcraft_geom::Vec3;
|
||
|
||
use crate::body::Body;
|
||
use crate::step_in::p21::{self, Param};
|
||
use crate::{KernelError, Result};
|
||
|
||
/// A named, optionally coloured body to export (coordinates in its part's frame, mm).
|
||
pub struct ExportBody<'a> {
|
||
pub name: String,
|
||
pub body: &'a Body,
|
||
pub color: Option<[f32; 3]>,
|
||
}
|
||
|
||
/// A part or assembly: its own bodies and placed child products.
|
||
pub struct ExportProduct<'a> {
|
||
pub name: String,
|
||
pub bodies: Vec<ExportBody<'a>>,
|
||
/// (child product index, rigid placement in this product, column-major 4×4, occurrence name).
|
||
pub children: Vec<(usize, [[f64; 4]; 4], String)>,
|
||
}
|
||
|
||
/// Header fields.
|
||
#[derive(Clone, Debug, Default)]
|
||
pub struct StepHeader {
|
||
/// FILE_NAME name (the file's own name).
|
||
pub file_name: String,
|
||
/// FILE_NAME time stamp (ISO 8601), empty when unknown.
|
||
pub time_stamp: String,
|
||
pub author: String,
|
||
pub organization: String,
|
||
/// FILE_DESCRIPTION text; `SolidCraft model` when empty.
|
||
pub description: String,
|
||
}
|
||
|
||
/// Entities whose identity is topological: never merged even when their text is equal.
|
||
const TOPOLOGY: &[&str] = &[
|
||
"VERTEX_POINT",
|
||
"EDGE_CURVE",
|
||
"ORIENTED_EDGE",
|
||
"EDGE_LOOP",
|
||
"FACE_BOUND",
|
||
"FACE_OUTER_BOUND",
|
||
"FACE_SURFACE",
|
||
"ADVANCED_FACE",
|
||
"ORIENTED_FACE",
|
||
"CLOSED_SHELL",
|
||
"OPEN_SHELL",
|
||
"ORIENTED_CLOSED_SHELL",
|
||
"MANIFOLD_SOLID_BREP",
|
||
"BREP_WITH_VOIDS",
|
||
];
|
||
|
||
fn real(x: f64) -> String {
|
||
if !x.is_finite() {
|
||
return "0.".into();
|
||
}
|
||
let s = format!("{x:?}");
|
||
match s.split_once('e') {
|
||
Some((m, e)) => {
|
||
let m = if m.contains('.') { m.to_string() } else { format!("{m}.") };
|
||
format!("{m}E{e}")
|
||
}
|
||
None if s.contains('.') => s,
|
||
None => format!("{s}."),
|
||
}
|
||
}
|
||
|
||
/// A STEP string literal (quotes doubled, non-ASCII as `\X2\` UTF-16 runs).
|
||
fn string(s: &str) -> String {
|
||
let mut o = String::from("'");
|
||
for c in s.chars() {
|
||
match c {
|
||
'\'' => o.push_str("''"),
|
||
'\\' => o.push_str("\\\\"),
|
||
c if c.is_ascii() && !c.is_ascii_control() => o.push(c),
|
||
c if c.is_ascii_control() => {}
|
||
c => {
|
||
o.push_str("\\X2\\");
|
||
let mut buf = [0u16; 2];
|
||
for u in c.encode_utf16(&mut buf) {
|
||
let _ = write!(o, "{u:04X}");
|
||
}
|
||
o.push_str("\\X0\\");
|
||
}
|
||
}
|
||
}
|
||
o.push('\'');
|
||
o
|
||
}
|
||
|
||
fn param(p: &Param, map: &HashMap<u64, u64>, o: &mut String) -> std::result::Result<(), String> {
|
||
match p {
|
||
Param::Int(i) => {
|
||
let _ = write!(o, "{i}");
|
||
}
|
||
Param::Real(x) => o.push_str(&real(*x)),
|
||
Param::Str(s) => o.push_str(&string(s)),
|
||
Param::Enum(e) => {
|
||
let _ = write!(o, ".{e}.");
|
||
}
|
||
Param::Ref(r) => {
|
||
let n = map.get(r).ok_or_else(|| format!("dangling reference #{r}"))?;
|
||
let _ = write!(o, "#{n}");
|
||
}
|
||
Param::List(v) => {
|
||
o.push('(');
|
||
params(v, map, o)?;
|
||
o.push(')');
|
||
}
|
||
Param::Typed(name, v) => {
|
||
o.push_str(name);
|
||
o.push('(');
|
||
params(v, map, o)?;
|
||
o.push(')');
|
||
}
|
||
Param::Binary(b) => {
|
||
let _ = write!(o, "\"{b}\"");
|
||
}
|
||
Param::Null => o.push('$'),
|
||
Param::Derived => o.push('*'),
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn params(v: &[Param], map: &HashMap<u64, u64>, o: &mut String) -> std::result::Result<(), String> {
|
||
for (i, p) in v.iter().enumerate() {
|
||
if i > 0 {
|
||
o.push(',');
|
||
}
|
||
param(p, map, o)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// The DATA section under construction.
|
||
#[derive(Default)]
|
||
struct Out {
|
||
lines: Vec<String>,
|
||
/// Geometry text → id (shared entities).
|
||
shared: HashMap<String, u64>,
|
||
/// Surfaces written with the opposite normal to the one they replace.
|
||
flipped: std::collections::HashSet<u64>,
|
||
/// B-spline cylinder and cone sheets of the body being copied to write as analytic surfaces,
|
||
/// with the direction of their parameter seam.
|
||
merged: HashMap<u64, V3>,
|
||
/// B-spline sheets of the body being copied to write cut down to their faces.
|
||
trimmed: HashMap<u64, truck_modeling::Surface>,
|
||
/// Faces of the body being copied: exchange id → written id.
|
||
faces_out: HashMap<u64, u64>,
|
||
}
|
||
|
||
impl Out {
|
||
fn add(&mut self, text: impl Into<String>) -> u64 {
|
||
self.lines.push(text.into());
|
||
self.lines.len() as u64
|
||
}
|
||
/// Add, or reuse an identical earlier entity (geometry only).
|
||
fn add_shared(&mut self, text: String) -> u64 {
|
||
if let Some(id) = self.shared.get(&text) {
|
||
return *id;
|
||
}
|
||
let id = self.add(text.clone());
|
||
self.shared.insert(text, id);
|
||
id
|
||
}
|
||
fn point(&mut self, p: [f64; 3]) -> u64 {
|
||
self.add_shared(format!("CARTESIAN_POINT('',({},{},{}))", real(p[0]), real(p[1]), real(p[2])))
|
||
}
|
||
fn direction(&mut self, d: [f64; 3]) -> u64 {
|
||
self.add_shared(format!("DIRECTION('',({},{},{}))", real(d[0]), real(d[1]), real(d[2])))
|
||
}
|
||
fn write_analytic(&mut self, a: &Analytic) -> u64 {
|
||
match a.kind {
|
||
AnalyticKind::Plane { o, z, x } => {
|
||
let ax = self.placement(o, z, x);
|
||
self.add_shared(format!("PLANE('',#{ax})"))
|
||
}
|
||
AnalyticKind::Cylinder { o, z, x, r } => {
|
||
let ax = self.placement(o, z, x);
|
||
self.add_shared(format!("CYLINDRICAL_SURFACE('',#{ax},{})", real(r)))
|
||
}
|
||
AnalyticKind::Cone { o, z, x, r, angle } => {
|
||
let ax = self.placement(o, z, x);
|
||
self.add_shared(format!("CONICAL_SURFACE('',#{ax},{},{})", real(r), real(angle)))
|
||
}
|
||
AnalyticKind::Sphere { o, z, x, r } => {
|
||
let ax = self.placement(o, z, x);
|
||
self.add_shared(format!("SPHERICAL_SURFACE('',#{ax},{})", real(r)))
|
||
}
|
||
AnalyticKind::Torus { o, z, x, big, small } => {
|
||
let ax = self.placement(o, z, x);
|
||
self.add_shared(format!("TOROIDAL_SURFACE('',#{ax},{},{})", real(big), real(small)))
|
||
}
|
||
AnalyticKind::HornTorus { o, z, x, big, small } => {
|
||
// Nine-point rational quadratic circles (quarter arcs, corner weights √½): the
|
||
// tube from the pole round and back, and the turn about z from x.
|
||
let y = cross(z, x);
|
||
let ring = |k: usize| {
|
||
let ang = std::f64::consts::FRAC_PI_4 * k as f64;
|
||
let (scale, w) = if k % 2 == 1 { (std::f64::consts::SQRT_2, std::f64::consts::FRAC_1_SQRT_2) } else { (1.0, 1.0) };
|
||
(ang.cos() * scale, ang.sin() * scale, w)
|
||
};
|
||
let (mut rows, mut weights) = (Vec::new(), Vec::new());
|
||
for i in 0..9 {
|
||
let (ci, si, wi) = ring(i);
|
||
let (rho, h) = (big - small * ci, small * si);
|
||
let (mut row, mut wrow) = (Vec::new(), Vec::new());
|
||
for j in 0..9 {
|
||
let (cj, sj, wj) = ring(j);
|
||
let pt = add(add(o, mul(z, h)), add(mul(x, rho * cj), mul(y, rho * sj)));
|
||
row.push(format!("#{}", self.point(pt)));
|
||
wrow.push(real(wi * wj));
|
||
}
|
||
rows.push(format!("({})", row.join(",")));
|
||
weights.push(format!("({})", wrow.join(",")));
|
||
}
|
||
self.add_shared(format!(
|
||
"(BOUNDED_SURFACE()B_SPLINE_SURFACE(2,2,({}),.UNSPECIFIED.,.T.,.T.,.F.)B_SPLINE_SURFACE_WITH_KNOTS((3,2,2,2,3),(3,2,2,2,3),(0.,0.25,0.5,0.75,1.),(0.,0.25,0.5,0.75,1.),.UNSPECIFIED.)GEOMETRIC_REPRESENTATION_ITEM()RATIONAL_B_SPLINE_SURFACE(({}))REPRESENTATION_ITEM('')SURFACE())",
|
||
rows.join(","),
|
||
weights.join(",")
|
||
))
|
||
}
|
||
}
|
||
}
|
||
/// A B-spline (or NURBS) surface; `None` for other surfaces.
|
||
fn write_sheet(&mut self, s: &truck_modeling::Surface) -> Option<u64> {
|
||
use truck_modeling::Surface;
|
||
let (rows, weights, (ku, kv), (du, dv)): (Vec<Vec<V3>>, Option<Vec<Vec<f64>>>, _, _) = match s {
|
||
Surface::BSplineSurface(b) => (
|
||
b.control_points().iter().map(|r| r.iter().map(|p| [p.x, p.y, p.z]).collect()).collect(),
|
||
None,
|
||
b.knot_vecs().clone(),
|
||
(b.udegree(), b.vdegree()),
|
||
),
|
||
Surface::NurbsSurface(n) => {
|
||
let b = n.non_rationalized();
|
||
let rows: Option<Vec<Vec<V3>>> = b
|
||
.control_points()
|
||
.iter()
|
||
.map(|r| r.iter().map(|p| (p.w.abs() > 1e-300).then(|| [p.x / p.w, p.y / p.w, p.z / p.w])).collect())
|
||
.collect();
|
||
(
|
||
rows?,
|
||
Some(b.control_points().iter().map(|r| r.iter().map(|p| p.w).collect()).collect()),
|
||
b.knot_vecs().clone(),
|
||
(b.udegree(), b.vdegree()),
|
||
)
|
||
}
|
||
_ => return None,
|
||
};
|
||
let net = rows
|
||
.iter()
|
||
.map(|r| format!("({})", r.iter().map(|p| format!("#{}", self.point(*p))).collect::<Vec<_>>().join(",")))
|
||
.collect::<Vec<_>>()
|
||
.join(",");
|
||
let list = |v: Vec<String>| v.join(",");
|
||
let ((ku, mu), (kv, mv)) = (ku.to_single_multi(), kv.to_single_multi());
|
||
let knots = format!(
|
||
"({}),({}),({}),({}),.UNSPECIFIED.",
|
||
list(mu.iter().map(|m| m.to_string()).collect()),
|
||
list(mv.iter().map(|m| m.to_string()).collect()),
|
||
list(ku.iter().map(|k| real(*k)).collect()),
|
||
list(kv.iter().map(|k| real(*k)).collect()),
|
||
);
|
||
let base = format!("{du},{dv},({net}),.UNSPECIFIED.,.U.,.U.,.U.");
|
||
Some(match weights {
|
||
None => self.add_shared(format!("B_SPLINE_SURFACE_WITH_KNOTS('',{base},{knots})")),
|
||
Some(w) => {
|
||
let w = w.iter().map(|r| format!("({})", list(r.iter().map(|x| real(*x)).collect()))).collect::<Vec<_>>().join(",");
|
||
self.add_shared(format!(
|
||
"(BOUNDED_SURFACE()B_SPLINE_SURFACE({base})B_SPLINE_SURFACE_WITH_KNOTS({knots})GEOMETRIC_REPRESENTATION_ITEM()RATIONAL_B_SPLINE_SURFACE(({w}))REPRESENTATION_ITEM('')SURFACE())"
|
||
))
|
||
}
|
||
})
|
||
}
|
||
fn placement(&mut self, o: [f64; 3], z: [f64; 3], x: [f64; 3]) -> u64 {
|
||
let (po, dz, dx) = (self.point(o), self.direction(z), self.direction(x));
|
||
self.add_shared(format!("AXIS2_PLACEMENT_3D('',#{po},#{dz},#{dx})"))
|
||
}
|
||
|
||
/// Copy a solid entity of a parsed file and everything it uses; returns its new id.
|
||
fn copy_solid(&mut self, ex: &p21::Exchange, root: u64, name: &str) -> std::result::Result<u64, String> {
|
||
let mut map: HashMap<u64, u64> = HashMap::new();
|
||
let seams = horn_seams(ex);
|
||
// Iterative post-order walk (children before parents).
|
||
let mut stack: Vec<(u64, bool)> = vec![(root, false)];
|
||
let mut guard = 0usize;
|
||
while let Some((id, done)) = stack.pop() {
|
||
guard += 1;
|
||
if guard > 50_000_000 {
|
||
return Err("solid too large".into());
|
||
}
|
||
if map.contains_key(&id) {
|
||
continue;
|
||
}
|
||
let e = ex.get(id).ok_or_else(|| format!("missing #{id}"))?;
|
||
// Revolutions with analytic profiles become cylinders, cones, spheres, tori and
|
||
// planes (what other systems recognise), with the face sense corrected.
|
||
if !done
|
||
&& e.name() == "SURFACE_OF_REVOLUTION"
|
||
&& let Some(mut a) = analytic_revolution(ex, e)
|
||
{
|
||
if let AnalyticKind::HornTorus { x, .. } = &mut a.kind
|
||
&& let Some(s) = seams.get(&id)
|
||
{
|
||
*x = *s;
|
||
}
|
||
let new = self.write_analytic(&a);
|
||
if a.flip {
|
||
self.flipped.insert(new);
|
||
}
|
||
map.insert(id, new);
|
||
continue;
|
||
}
|
||
// Flat B-spline sheets are planes; ruled ones become cylinders and cones when
|
||
// `analytic_sheets` chose them (their pieces merged, or a lone piece's edges allow).
|
||
if !done
|
||
&& let Some(a) = planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| {
|
||
let seam = self.merged.get(&id)?;
|
||
let mut a = ruled_bspline(ex, e)?;
|
||
if let AnalyticKind::Cylinder { x, .. } | AnalyticKind::Cone { x, .. } = &mut a.kind {
|
||
*x = *seam;
|
||
}
|
||
Some(a)
|
||
})
|
||
{
|
||
let new = self.write_analytic(&a);
|
||
if a.flip {
|
||
self.flipped.insert(new);
|
||
}
|
||
map.insert(id, new);
|
||
continue;
|
||
}
|
||
if !done && let Some(sheet) = self.trimmed.get(&id).cloned() {
|
||
let new = self.write_sheet(&sheet).ok_or_else(|| format!("cannot write the cut sheet #{id}"))?;
|
||
map.insert(id, new);
|
||
continue;
|
||
}
|
||
if !done {
|
||
stack.push((id, true));
|
||
let mut refs = Vec::new();
|
||
fn collect(p: &Param, out: &mut Vec<u64>) {
|
||
match p {
|
||
Param::Ref(r) => out.push(*r),
|
||
Param::List(v) | Param::Typed(_, v) => v.iter().for_each(|x| collect(x, out)),
|
||
_ => {}
|
||
}
|
||
}
|
||
e.records.iter().flat_map(|r| &r.params).for_each(|p| collect(p, &mut refs));
|
||
stack.extend(refs.into_iter().filter(|r| !map.contains_key(r)).map(|r| (r, false)));
|
||
continue;
|
||
}
|
||
let mut text = String::new();
|
||
let is_root = id == root;
|
||
if e.is_complex() {
|
||
text.push('(');
|
||
for r in &e.records {
|
||
text.push_str(&r.name);
|
||
text.push('(');
|
||
params(&r.params, &map, &mut text)?;
|
||
text.push(')');
|
||
}
|
||
text.push(')');
|
||
} else {
|
||
// Advanced breps use advanced faces (same attributes as truck's face surfaces).
|
||
let ename = if e.name() == "FACE_SURFACE" { "ADVANCED_FACE" } else { e.name() };
|
||
text.push_str(ename);
|
||
text.push('(');
|
||
let mut ps = e.params().to_vec();
|
||
if is_root && let Some(first) = ps.first_mut() {
|
||
*first = Param::Str(name.to_string());
|
||
}
|
||
// A face on a surface written with the opposite normal flips its sense.
|
||
if ename == "ADVANCED_FACE"
|
||
&& ps.get(2).and_then(Param::as_ref_id).and_then(|g| map.get(&g)).is_some_and(|g| self.flipped.contains(g))
|
||
&& let Some(Param::Enum(sense)) = ps.get_mut(3)
|
||
{
|
||
*sense = if sense == "T" { "F".into() } else { "T".into() };
|
||
}
|
||
params(&ps, &map, &mut text)?;
|
||
text.push(')');
|
||
}
|
||
let topo = TOPOLOGY.contains(&e.name());
|
||
let new = if topo { self.add(text) } else { self.add_shared(text) };
|
||
map.insert(id, new);
|
||
if matches!(e.name(), "FACE_SURFACE" | "ADVANCED_FACE") {
|
||
self.faces_out.insert(id, new);
|
||
}
|
||
}
|
||
map.get(&root).copied().ok_or_else(|| "solid not copied".into())
|
||
}
|
||
}
|
||
|
||
/// An analytic surface found behind a surface of revolution.
|
||
#[derive(Clone, Copy)]
|
||
struct Analytic {
|
||
kind: AnalyticKind,
|
||
/// The analytic surface's normal is opposite to the revolution's (ISO 10303-42 normals).
|
||
flip: bool,
|
||
}
|
||
|
||
#[derive(Clone, Copy)]
|
||
enum AnalyticKind {
|
||
Plane {
|
||
o: V3,
|
||
z: V3,
|
||
x: V3,
|
||
},
|
||
Cylinder {
|
||
o: V3,
|
||
z: V3,
|
||
x: V3,
|
||
r: f64,
|
||
},
|
||
Cone {
|
||
o: V3,
|
||
z: V3,
|
||
x: V3,
|
||
r: f64,
|
||
angle: f64,
|
||
},
|
||
Sphere {
|
||
o: V3,
|
||
z: V3,
|
||
x: V3,
|
||
r: f64,
|
||
},
|
||
Torus {
|
||
o: V3,
|
||
z: V3,
|
||
x: V3,
|
||
big: f64,
|
||
small: f64,
|
||
},
|
||
/// A torus whose tube reaches its axis (a horn torus, as a tight sweep makes): no valid
|
||
/// TOROIDAL_SURFACE, so a rational B-spline (tube angle from the pole at the axis, then the
|
||
/// turn from x), as other systems write it. x is the turn's parameter seam.
|
||
HornTorus {
|
||
o: V3,
|
||
z: V3,
|
||
x: V3,
|
||
big: f64,
|
||
small: f64,
|
||
},
|
||
}
|
||
|
||
type V3 = [f64; 3];
|
||
|
||
fn sub(a: V3, b: V3) -> V3 {
|
||
[a[0] - b[0], a[1] - b[1], a[2] - b[2]]
|
||
}
|
||
fn add(a: V3, b: V3) -> V3 {
|
||
[a[0] + b[0], a[1] + b[1], a[2] + b[2]]
|
||
}
|
||
fn mul(a: V3, k: f64) -> V3 {
|
||
[a[0] * k, a[1] * k, a[2] * k]
|
||
}
|
||
fn dot(a: V3, b: V3) -> f64 {
|
||
a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
|
||
}
|
||
fn cross(a: V3, b: V3) -> V3 {
|
||
[a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]
|
||
}
|
||
fn norm(a: V3) -> f64 {
|
||
dot(a, a).sqrt()
|
||
}
|
||
fn unit(a: V3) -> Option<V3> {
|
||
let n = norm(a);
|
||
(n > 1e-12 && n.is_finite()).then(|| mul(a, 1.0 / n))
|
||
}
|
||
|
||
/// Circle through three points: centre, radius, unit normal.
|
||
fn circle3(a: V3, b: V3, c: V3) -> Option<(V3, f64, V3)> {
|
||
let (ab, ac) = (sub(b, a), sub(c, a));
|
||
let n = cross(ab, ac);
|
||
let n2 = dot(n, n);
|
||
if !(n2 > 1e-24) {
|
||
return None;
|
||
}
|
||
let t = add(mul(cross(n, ab), dot(ac, ac)), mul(cross(ac, n), dot(ab, ab)));
|
||
let center = add(a, mul(t, 0.5 / n2));
|
||
Some((center, norm(sub(a, center)), unit(n)?))
|
||
}
|
||
|
||
/// The analytic surface a surface of revolution is, if its profile is a line or a circular arc
|
||
/// in a plane through the axis.
|
||
fn analytic_revolution(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {
|
||
use crate::step_in::geom::{self, CurveGeo};
|
||
use truck_modeling::{BoundedCurve, ParametricCurve};
|
||
let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };
|
||
let p = e.params();
|
||
let (ao, ad) = geom::axis1(&cx, p.get(2)?.as_ref_id()?).ok()?;
|
||
let (oa, a) = ([ao.x, ao.y, ao.z], [ad.x, ad.y, ad.z]);
|
||
let g = geom::curve(&cx, p.get(1)?.as_ref_id()?, 0).ok()?;
|
||
let radial = |q: V3| {
|
||
let v = sub(q, oa);
|
||
sub(v, mul(a, dot(v, a)))
|
||
};
|
||
let on_axis = |q: V3| add(oa, mul(a, dot(sub(q, oa), a)));
|
||
// Profile samples and tangents.
|
||
let eval: Box<dyn Fn(f64) -> V3> = match &g {
|
||
CurveGeo::Line { p, d } => {
|
||
let (p, d) = ([p.x, p.y, p.z], [d.x, d.y, d.z]);
|
||
Box::new(move |t| add(p, mul(d, t)))
|
||
}
|
||
CurveGeo::BSpline(c) => {
|
||
let c = c.clone();
|
||
let (t0, t1) = c.range_tuple();
|
||
Box::new(move |s| {
|
||
let q = c.subs(t0 + (t1 - t0) * s);
|
||
[q.x, q.y, q.z]
|
||
})
|
||
}
|
||
CurveGeo::Nurbs(c) => {
|
||
let c = c.clone();
|
||
let (t0, t1) = c.range_tuple();
|
||
Box::new(move |s| {
|
||
let q = c.subs(t0 + (t1 - t0) * s);
|
||
[q.x, q.y, q.z]
|
||
})
|
||
}
|
||
CurveGeo::Conic { .. } | CurveGeo::Hyperbola { .. } | CurveGeo::Parabola { .. } => return None,
|
||
};
|
||
// A sample point off the axis, its revolution normal (∂S/∂angle × ∂S/∂profile).
|
||
let sample =
|
||
[0.37, 0.61, 0.23, 0.79].into_iter().map(|t| (eval(t), sub(eval(t + 1e-4), eval(t - 1e-4)))).find(|(q, _)| norm(radial(*q)) > 1e-6)?;
|
||
let (q, dq) = sample;
|
||
let n_rev = cross(cross(a, sub(q, oa)), dq);
|
||
let eq = unit(radial(q))?;
|
||
let (kind, n_an) = match &g {
|
||
CurveGeo::Line { d, .. } => {
|
||
let d = unit([d.x, d.y, d.z])?;
|
||
// Coplanar with the axis?
|
||
if dot(cross(d, a), eq).abs() > 1e-9 {
|
||
return None;
|
||
}
|
||
let (da, dr) = (dot(d, a), dot(d, eq));
|
||
if dr.abs() < 1e-12 {
|
||
let r = norm(radial(q));
|
||
(AnalyticKind::Cylinder { o: oa, z: a, x: eq, r }, eq)
|
||
} else if da.abs() < 1e-12 {
|
||
(AnalyticKind::Plane { o: on_axis(q), z: a, x: eq }, a)
|
||
} else {
|
||
// Open the cone along +z: the radius grows that way.
|
||
let z = if dr * da > 0.0 { a } else { mul(a, -1.0) };
|
||
let angle = (dr.abs() / da.abs()).atan();
|
||
let r = norm(radial(q));
|
||
let n = sub(mul(eq, angle.cos()), mul(z, angle.sin()));
|
||
(AnalyticKind::Cone { o: on_axis(q), z, x: eq, r, angle }, n)
|
||
}
|
||
}
|
||
_ => {
|
||
let (c, r, nc) = circle3(eval(0.0), eval(0.5), eval(1.0))?;
|
||
// Every sample on the circle, the circle's plane through the axis.
|
||
if (0..=8).any(|i| (norm(sub(eval(i as f64 / 8.0), c)) - r).abs() > 1e-7 * (1.0 + r)) {
|
||
return None;
|
||
}
|
||
if dot(nc, a).abs() > 1e-9 || dot(sub(c, oa), nc).abs() > 1e-7 * (1.0 + r) {
|
||
return None;
|
||
}
|
||
let big = norm(radial(c));
|
||
if big < 1e-9 * (1.0 + r) {
|
||
(AnalyticKind::Sphere { o: c, z: a, x: eq, r }, sub(q, c))
|
||
} else {
|
||
let ec = unit(radial(c))?;
|
||
let o = on_axis(c);
|
||
if (big - r).abs() <= 1e-6 * (1.0 + r) {
|
||
(AnalyticKind::HornTorus { o, z: a, x: mul(ec, -1.0), big: r, small: r }, sub(q, add(o, mul(eq, r))))
|
||
} else if big < r {
|
||
// A spindle torus (tube crossing the axis) stays a surface of revolution.
|
||
return None;
|
||
} else {
|
||
(AnalyticKind::Torus { o, z: a, x: ec, big, small: r }, sub(q, add(o, mul(eq, big))))
|
||
}
|
||
}
|
||
}
|
||
};
|
||
let flip = dot(n_rev, n_an) < 0.0;
|
||
if !dot(n_rev, n_an).is_finite() || dot(n_rev, n_an).abs() < 1e-12 {
|
||
return None;
|
||
}
|
||
Some(Analytic { kind, flip })
|
||
}
|
||
|
||
/// Two analytic surfaces are the same surface (same kind, frame-independent parameters).
|
||
fn same_analytic(a: &AnalyticKind, b: &AnalyticKind) -> bool {
|
||
let close = |x: f64, y: f64| (x - y).abs() <= 1e-7 * (1.0 + x.abs().max(y.abs()));
|
||
let same_pt = |p: V3, q: V3| norm(sub(p, q)) <= 1e-7 * (1.0 + norm(p));
|
||
let parallel = |p: V3, q: V3| norm(cross(p, q)) <= 1e-9;
|
||
let on_line = |p: V3, o: V3, d: V3| norm(cross(sub(p, o), d)) <= 1e-7 * (1.0 + norm(p));
|
||
match (a, b) {
|
||
(AnalyticKind::Cylinder { o, z, r, .. }, AnalyticKind::Cylinder { o: o2, z: z2, r: r2, .. }) => {
|
||
parallel(*z, *z2) && on_line(*o2, *o, *z) && close(*r, *r2)
|
||
}
|
||
(AnalyticKind::Cone { o, z, r, angle, .. }, AnalyticKind::Cone { o: o2, z: z2, r: r2, angle: a2, .. }) => {
|
||
// Same apex, axis direction and angle.
|
||
let apex = |o: V3, z: V3, r: f64, an: f64| sub(o, mul(z, r / an.tan()));
|
||
dot(*z, *z2) > 1.0 - 1e-9 && close(*angle, *a2) && same_pt(apex(*o, *z, *r, *angle), apex(*o2, *z2, *r2, *a2))
|
||
}
|
||
(AnalyticKind::Sphere { o, r, .. }, AnalyticKind::Sphere { o: o2, r: r2, .. }) => same_pt(*o, *o2) && close(*r, *r2),
|
||
(AnalyticKind::Torus { o, z, big, small, .. }, AnalyticKind::Torus { o: o2, z: z2, big: b2, small: s2, .. }) => {
|
||
same_pt(*o, *o2) && parallel(*z, *z2) && close(*big, *b2) && close(*small, *s2)
|
||
}
|
||
(AnalyticKind::HornTorus { o, z, big, .. }, AnalyticKind::HornTorus { o: o2, z: z2, big: b2, .. }) => {
|
||
same_pt(*o, *o2) && parallel(*z, *z2) && close(*big, *b2)
|
||
}
|
||
(AnalyticKind::Plane { o, z, .. }, AnalyticKind::Plane { o: o2, z: z2, .. }) => {
|
||
parallel(*z, *z2) && dot(sub(*o2, *o), *z).abs() <= 1e-7 * (1.0 + norm(*o))
|
||
}
|
||
_ => false,
|
||
}
|
||
}
|
||
|
||
/// The outward normal sign of a face relative to its analytic surface's normal.
|
||
fn face_normal_sign(a: &AnalyticKind, z_written: V3, flip: bool, sense: bool) -> f64 {
|
||
// Planes compare their written normal directly; the others are always outward-normal kinds.
|
||
let base = match a {
|
||
AnalyticKind::Plane { z, .. } => dot(*z, z_written).signum(),
|
||
_ => 1.0,
|
||
};
|
||
base * if flip != sense { 1.0 } else { -1.0 }
|
||
}
|
||
|
||
/// A B-spline surface that is flat (a sheet swept along a line, as truck makes for extrusions):
|
||
/// the plane with the surface's own normal, so it can be written as a PLANE.
|
||
fn planar_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<AnalyticKind> {
|
||
use truck_modeling::{BoundedSurface, ParametricSurface, ParametricSurface3D};
|
||
if !(e.has("B_SPLINE_SURFACE") || e.name() == "B_SPLINE_SURFACE_WITH_KNOTS") {
|
||
return None;
|
||
}
|
||
let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };
|
||
let s = crate::step_in::geom::bspline_surface(&cx, e).ok()?;
|
||
let (ctrl, (u0, u1), (v0, v1)) = match &s {
|
||
truck_modeling::Surface::BSplineSurface(b) => {
|
||
(b.control_points().iter().flatten().map(|p| [p.x, p.y, p.z]).collect::<Vec<V3>>(), b.range_tuple().0, b.range_tuple().1)
|
||
}
|
||
truck_modeling::Surface::NurbsSurface(n) => {
|
||
let pts = n.non_rationalized().control_points().iter().flatten().map(|p| [p.x / p.w, p.y / p.w, p.z / p.w]).collect::<Vec<V3>>();
|
||
let (ru, rv) = n.range_tuple();
|
||
(pts, ru, rv)
|
||
}
|
||
_ => return None,
|
||
};
|
||
let (um, vm) = ((u0 + u1) / 2.0, (v0 + v1) / 2.0);
|
||
let n = s.normal(um, vm);
|
||
let z = unit([n.x, n.y, n.z])?;
|
||
let o = s.subs(um, vm);
|
||
let o = [o.x, o.y, o.z];
|
||
let du = s.uder(um, vm);
|
||
let x = unit(sub([du.x, du.y, du.z], mul(z, dot([du.x, du.y, du.z], z))))?;
|
||
let size = ctrl.iter().map(|p| norm(sub(*p, o))).fold(0.0, f64::max);
|
||
// Every control point on the plane (a flat net gives a flat surface, rational or not).
|
||
if ctrl.iter().any(|p| dot(sub(*p, o), z).abs() > 1e-9 * (1.0 + size)) {
|
||
return None;
|
||
}
|
||
Some(AnalyticKind::Plane { o, z, x })
|
||
}
|
||
|
||
/// A B-spline surface that is a circular cylinder or cone: straight rulings between two coaxial
|
||
/// circles or arcs (or an arc and the cone's apex), as truck makes for extruded round profiles,
|
||
/// rounds along straight edges and countersinks. With its normal direction relative to the
|
||
/// surface's outward normal.
|
||
fn ruled_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {
|
||
use truck_modeling::{ParametricSurface, ParametricSurface3D};
|
||
if !(e.has("B_SPLINE_SURFACE") || e.name() == "B_SPLINE_SURFACE_WITH_KNOTS") {
|
||
return None;
|
||
}
|
||
let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };
|
||
let s = crate::step_in::geom::bspline_surface(&cx, e).ok()?;
|
||
let (Some((u0, u1)), Some((v0, v1))) = s.try_range_tuple() else { return None };
|
||
let at = |u: f64, v: f64| {
|
||
let p = s.subs(u, v);
|
||
[p.x, p.y, p.z]
|
||
};
|
||
// Which parameter runs along the rulings: straight from one end to the other at every point
|
||
// of the profile.
|
||
for along_v in [true, false] {
|
||
let point = |t: f64, w: f64| if along_v { at(u0 + (u1 - u0) * t, v0 + (v1 - v0) * w) } else { at(u0 + (u1 - u0) * w, v0 + (v1 - v0) * t) };
|
||
let grid: Vec<Vec<V3>> = (0..=4).map(|m| (0..=8).map(|k| point(k as f64 / 8.0, m as f64 / 4.0)).collect()).collect();
|
||
let (Some(p0), Some(p1)) = (grid.first(), grid.last()) else { continue };
|
||
let Some(&first) = p0.first() else { continue };
|
||
let scale = grid.iter().flatten().map(|p| norm(sub(*p, first))).fold(0.0, f64::max);
|
||
let tol = 1e-7 * (1.0 + scale);
|
||
let straight = (0..=8).all(|k| {
|
||
let (Some(&a), Some(&b)) = (p0.get(k), p1.get(k)) else { return false };
|
||
let Some(d) = unit(sub(b, a)) else { return false };
|
||
grid.iter().all(|row| row.get(k).is_some_and(|q| norm(cross(sub(*q, a), d)) <= tol))
|
||
});
|
||
if !straight {
|
||
continue;
|
||
}
|
||
// Each end: a circle (centre, radius, axis) or a single point (a cone's apex).
|
||
let ring = |prof: &[V3]| -> Option<(V3, f64, Option<V3>)> {
|
||
let &a = prof.first()?;
|
||
if prof.iter().all(|p| norm(sub(*p, a)) <= tol) {
|
||
return Some((a, 0.0, None));
|
||
}
|
||
let (&b, &c, &h) = (prof.get(4)?, prof.get(8)?, prof.get(2)?);
|
||
let (centre, r, n) = circle3(a, b, c).or_else(|| circle3(a, h, b))?;
|
||
prof.iter().all(|p| (norm(sub(*p, centre)) - r).abs() <= tol).then_some((centre, r, Some(n)))
|
||
};
|
||
let ((c0, r0, n0), (c1, r1, n1)) = (ring(p0)?, ring(p1)?);
|
||
let axis = unit(sub(c1, c0))?;
|
||
if [n0, n1].iter().flatten().any(|n| norm(cross(*n, axis)) > 1e-7) || (n0.is_none() && n1.is_none()) {
|
||
return None;
|
||
}
|
||
let height = norm(sub(c1, c0));
|
||
// The radius grows along z (a cylinder keeps the sweep's direction).
|
||
let (o, z, r, angle) = if (r1 - r0).abs() <= tol {
|
||
(c0, axis, r0, 0.0)
|
||
} else if r1 > r0 {
|
||
(c1, axis, r1, ((r1 - r0) / height).atan())
|
||
} else {
|
||
(c0, mul(axis, -1.0), r0, ((r0 - r1) / height).atan())
|
||
};
|
||
let radius_at = |q: V3| r + dot(sub(q, o), z) * angle.tan();
|
||
let radial = |q: V3| {
|
||
let v = sub(q, o);
|
||
sub(v, mul(z, dot(v, z)))
|
||
};
|
||
if grid.iter().flatten().any(|q| (norm(radial(*q)) - radius_at(*q)).abs() > tol) {
|
||
return None;
|
||
}
|
||
// The surface's own normal against the outward one, mid-face.
|
||
let (um, vm) = ((u0 + u1) / 2.0, (v0 + v1) / 2.0);
|
||
let nn = s.normal(um, vm);
|
||
let q = at(um, vm);
|
||
let eq = unit(radial(q))?;
|
||
let outward = sub(mul(eq, angle.cos()), mul(z, angle.sin()));
|
||
let flip = dot([nn.x, nn.y, nn.z], outward) < 0.0;
|
||
// The parameter seam opposite the middle of the sheet, away from its edges.
|
||
let x = mul(eq, -1.0);
|
||
let kind = if angle == 0.0 { AnalyticKind::Cylinder { o, z, x, r } } else { AnalyticKind::Cone { o, z, x, r, angle } };
|
||
return Some(Analytic { kind, flip });
|
||
}
|
||
None
|
||
}
|
||
|
||
/// A B-spline surface that is really a plane, a cylinder or a cone.
|
||
fn analytic_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {
|
||
planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| ruled_bspline(ex, e))
|
||
}
|
||
|
||
/// Every edge of a face on a cylinder or cone is a circle square to its axis or one of its
|
||
/// rulings (a line along the axis, or through a cone's apex). Faces bounded by other curves (a
|
||
/// hole crossing a tube wall) keep their B-spline sheet: readers lay those curves out far more
|
||
/// slowly on the analytic surface than on the sheet they came with.
|
||
fn square_or_ruled(ex: &p21::Exchange, fe: &p21::Entity, kind: &AnalyticKind) -> bool {
|
||
let (z, apex) = match *kind {
|
||
AnalyticKind::Cylinder { z, .. } => (z, None),
|
||
AnalyticKind::Cone { o, z, r, angle, .. } if angle.tan() > 1e-12 => (z, Some(sub(o, mul(z, r / angle.tan())))),
|
||
_ => return false,
|
||
};
|
||
face_edges(ex, fe).is_some_and(|ls| {
|
||
ls.iter().flatten().all(|(x, _)| {
|
||
edge_samples(ex, *x).is_some_and(|pts| {
|
||
let Some(&q0) = pts.first() else { return false };
|
||
let tol = 1e-7 * (1.0 + norm(q0));
|
||
let ruling = match apex {
|
||
None => pts.iter().all(|q| norm(cross(sub(*q, q0), z)) <= tol),
|
||
Some(a) => pts.iter().all(|q| norm(cross(sub(*q, a), sub(q0, a))) <= tol * (1.0 + norm(sub(q0, a)))),
|
||
};
|
||
ruling || pts.iter().all(|q| dot(sub(*q, q0), z).abs() <= tol)
|
||
})
|
||
})
|
||
})
|
||
}
|
||
|
||
/// Points along an edge's curve (its ends for a line, None for a conic it cannot sample).
|
||
fn edge_samples(ex: &p21::Exchange, edge: u64) -> Option<Vec<V3>> {
|
||
edge_points(ex, edge, 4)
|
||
}
|
||
|
||
/// `n + 1` points along an edge's curve, ends included (its ends for a line, None for a conic it
|
||
/// cannot sample).
|
||
fn edge_points(ex: &p21::Exchange, edge: u64, n: usize) -> Option<Vec<V3>> {
|
||
use truck_modeling::{BoundedCurve, ParametricCurve};
|
||
let p = ex.get(edge)?.params();
|
||
let ends = [vertex_point(ex, p.get(1)?.as_ref_id()?)?, vertex_point(ex, p.get(2)?.as_ref_id()?)?];
|
||
let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };
|
||
let sample = |f: &dyn Fn(f64) -> truck_modeling::Point3, (t0, t1): (f64, f64)| {
|
||
(0..=n).map(|k| f(t0 + (t1 - t0) * k as f64 / n.max(1) as f64)).map(|q| [q.x, q.y, q.z]).collect::<Vec<V3>>()
|
||
};
|
||
match crate::step_in::geom::curve(&cx, p.get(3)?.as_ref_id()?, 0).ok()? {
|
||
crate::step_in::geom::CurveGeo::Line { .. } => Some(ends.to_vec()),
|
||
crate::step_in::geom::CurveGeo::BSpline(c) => Some(sample(&|t| c.subs(t), c.range_tuple())),
|
||
crate::step_in::geom::CurveGeo::Nurbs(c) => Some(sample(&|t| c.subs(t), c.range_tuple())),
|
||
crate::step_in::geom::CurveGeo::Conic { .. }
|
||
| crate::step_in::geom::CurveGeo::Hyperbola { .. }
|
||
| crate::step_in::geom::CurveGeo::Parabola { .. } => None,
|
||
}
|
||
}
|
||
|
||
fn vertex_point(ex: &p21::Exchange, v: u64) -> Option<V3> {
|
||
let p = ex.get(ex.get(v)?.params().get(1)?.as_ref_id()?)?;
|
||
let c = p.params().get(1)?.as_list()?;
|
||
Some([c.first()?.as_f64()?, c.get(1)?.as_f64()?, c.get(2)?.as_f64()?])
|
||
}
|
||
|
||
/// For each horn torus revolution, a turn direction away from its faces (the B-spline's
|
||
/// parameter seam must not cross them): opposite their vertices' mean direction about the axis.
|
||
fn horn_seams(ex: &p21::Exchange) -> HashMap<u64, V3> {
|
||
let mut out = HashMap::new();
|
||
for fe in ex.entities.values() {
|
||
if !matches!(fe.name(), "FACE_SURFACE" | "ADVANCED_FACE") {
|
||
continue;
|
||
}
|
||
let Some(sid) = fe.params().get(2).and_then(Param::as_ref_id) else { continue };
|
||
let Some(se) = ex.get(sid).filter(|e| e.name() == "SURFACE_OF_REVOLUTION") else { continue };
|
||
let Some(Analytic { kind: AnalyticKind::HornTorus { o, z, .. }, .. }) = analytic_revolution(ex, se) else { continue };
|
||
let Some(loops) = face_edges(ex, fe) else { continue };
|
||
let mut mean = [0.0; 3];
|
||
for (e, _) in loops.iter().flatten() {
|
||
for k in [1, 2] {
|
||
let Some(q) = ex.get(*e).and_then(|e| e.params().get(k)).and_then(Param::as_ref_id).and_then(|v| vertex_point(ex, v)) else {
|
||
continue;
|
||
};
|
||
let v = sub(q, o);
|
||
if let Some(r) = unit(sub(v, mul(z, dot(v, z)))) {
|
||
mean = add(mean, r);
|
||
}
|
||
}
|
||
}
|
||
if let Some(m) = unit(mean) {
|
||
out.insert(sid, mul(m, -1.0));
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// Zero-length edges (truck sweeps a profile point on the axis into one) removed and their
|
||
/// vertices joined: other systems reject a pole written as an ordinary edge.
|
||
fn collapse_short_edges(ex: &mut p21::Exchange) {
|
||
let ends = |e: &p21::Entity| Some((e.params().get(1)?.as_ref_id()?, e.params().get(2)?.as_ref_id()?));
|
||
let mut join: HashMap<u64, u64> = HashMap::new();
|
||
let mut dead = std::collections::HashSet::new();
|
||
let mut ids: Vec<u64> = ex.entities.iter().filter(|(_, e)| e.name() == "EDGE_CURVE").map(|(i, _)| *i).collect();
|
||
ids.sort();
|
||
for id in ids {
|
||
let Some(e) = ex.get(id) else { continue };
|
||
let Some((a, b)) = ends(e) else { continue };
|
||
let (Some(pa), Some(pb)) = (vertex_point(ex, a), vertex_point(ex, b)) else { continue };
|
||
if a == b || norm(sub(pa, pb)) > 1e-6 * (1.0 + norm(pa)) {
|
||
continue;
|
||
}
|
||
// The curve itself must be short too (not a whole circle between two coincident vertices).
|
||
let short = e.params().get(3).and_then(Param::as_ref_id).and_then(|c| {
|
||
use truck_modeling::{BoundedCurve, ParametricCurve};
|
||
let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };
|
||
let mid = match crate::step_in::geom::curve(&cx, c, 0).ok()? {
|
||
crate::step_in::geom::CurveGeo::Line { .. } => return Some(true),
|
||
crate::step_in::geom::CurveGeo::BSpline(c) => c.subs((c.range_tuple().0 + c.range_tuple().1) / 2.0),
|
||
crate::step_in::geom::CurveGeo::Nurbs(c) => c.subs((c.range_tuple().0 + c.range_tuple().1) / 2.0),
|
||
crate::step_in::geom::CurveGeo::Conic { .. }
|
||
| crate::step_in::geom::CurveGeo::Hyperbola { .. }
|
||
| crate::step_in::geom::CurveGeo::Parabola { .. } => return Some(false),
|
||
};
|
||
Some(norm(sub([mid.x, mid.y, mid.z], pa)) <= 1e-6 * (1.0 + norm(pa)))
|
||
});
|
||
if short != Some(true) {
|
||
continue;
|
||
}
|
||
let find = |join: &HashMap<u64, u64>, mut v: u64| {
|
||
while let Some(n) = join.get(&v) {
|
||
v = *n;
|
||
}
|
||
v
|
||
};
|
||
let (ra, rb) = (find(&join, a), find(&join, b));
|
||
if ra != rb {
|
||
join.insert(rb, ra);
|
||
}
|
||
dead.insert(id);
|
||
}
|
||
if dead.is_empty() {
|
||
return;
|
||
}
|
||
// A loop made only of such edges (a pole loop) keeps them all.
|
||
let oe_edge = |ex: &p21::Exchange, oe: &Param| oe.as_ref_id().and_then(|o| ex.get(o)).and_then(|o| o.params().get(3)).and_then(Param::as_ref_id);
|
||
let loops: Vec<u64> = ex.entities.iter().filter(|(_, e)| e.name() == "EDGE_LOOP").map(|(i, _)| *i).collect();
|
||
for l in &loops {
|
||
let Some(list) = ex.get(*l).and_then(|e| e.params().get(1)).and_then(Param::as_list) else { continue };
|
||
if list.iter().all(|oe| oe_edge(ex, oe).is_some_and(|e| dead.contains(&e))) {
|
||
return;
|
||
}
|
||
}
|
||
for l in loops {
|
||
let Some(list) = ex.get(l).and_then(|e| e.params().get(1)).and_then(Param::as_list) else { continue };
|
||
let kept: Vec<Param> = list.iter().filter(|oe| !oe_edge(ex, oe).is_some_and(|e| dead.contains(&e))).cloned().collect();
|
||
if let Some(r) = ex.entities.get_mut(&l).and_then(|e| e.records.first_mut())
|
||
&& let Some(slot) = r.params.get_mut(1)
|
||
{
|
||
*slot = Param::List(kept);
|
||
}
|
||
}
|
||
let find = |mut v: u64| {
|
||
while let Some(n) = join.get(&v) {
|
||
v = *n;
|
||
}
|
||
v
|
||
};
|
||
for e in ex.entities.values_mut() {
|
||
if e.name() != "EDGE_CURVE" {
|
||
continue;
|
||
}
|
||
if let Some(r) = e.records.first_mut() {
|
||
for k in [1, 2] {
|
||
if let Some(slot) = r.params.get_mut(k)
|
||
&& let Some(v) = slot.as_ref_id()
|
||
{
|
||
*slot = Param::Ref(find(v));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Oriented edges (edge id, forward) of a face's bounds.
|
||
fn face_edges(ex: &p21::Exchange, face: &p21::Entity) -> Option<Vec<Vec<(u64, bool)>>> {
|
||
let mut loops = Vec::new();
|
||
for b in face.params().get(1)?.as_list()? {
|
||
let fb = ex.get(b.as_ref_id()?)?;
|
||
let lp = ex.get(fb.params().get(1)?.as_ref_id()?)?;
|
||
if lp.name() != "EDGE_LOOP" {
|
||
return None;
|
||
}
|
||
let orient = fb.params().get(2)?.as_bool()?;
|
||
let mut v = Vec::new();
|
||
for oe in lp.params().get(1)?.as_list()? {
|
||
let oe = ex.get(oe.as_ref_id()?)?;
|
||
if oe.name() != "ORIENTED_EDGE" {
|
||
return None;
|
||
}
|
||
v.push((oe.params().get(3)?.as_ref_id()?, oe.params().get(4)?.as_bool()?));
|
||
}
|
||
if !orient {
|
||
v.reverse();
|
||
v.iter_mut().for_each(|e| e.1 = !e.1);
|
||
}
|
||
loops.push(v);
|
||
}
|
||
Some(loops)
|
||
}
|
||
|
||
/// Faces that truck splits (a revolution in two or three turns) joined back into one face per
|
||
/// analytic surface, by dropping the edges between them. Faces whose union would lose all its
|
||
/// edges, or whose leftover edges do not close into loops, stay apart. Returns the surfaces of
|
||
/// merged faces.
|
||
fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>, keep: &[Vec<Vec3>]) -> std::collections::HashSet<u64> {
|
||
// An edge on a line the user split along: every sample within a hair of the polyline.
|
||
let on_split = |ex: &p21::Exchange, e: u64| -> bool {
|
||
let Some(pts) = edge_samples(ex, e) else { return false };
|
||
let pts: Vec<Vec3> = pts.iter().map(|q| Vec3::new(q[0], q[1], q[2])).collect();
|
||
crate::heal::on_split_line(&pts, keep)
|
||
};
|
||
let mut merged_surfaces = std::collections::HashSet::new();
|
||
let mut next = ex.entities.keys().max().copied().unwrap_or(0) + 1;
|
||
let shells: Vec<u64> = ex.entities.iter().filter(|(_, e)| matches!(e.name(), "CLOSED_SHELL" | "OPEN_SHELL")).map(|(i, _)| *i).collect();
|
||
// Each surface's analytic form, worked out once (merged faces keep a piece's surface).
|
||
let mut cache: HashMap<u64, Option<Analytic>> = HashMap::new();
|
||
for sh in shells {
|
||
for _round in 0..64 {
|
||
let Some(faces) = ex
|
||
.get(sh)
|
||
.and_then(|e| e.params().get(1))
|
||
.and_then(Param::as_list)
|
||
.map(|l| l.iter().filter_map(Param::as_ref_id).collect::<Vec<u64>>())
|
||
else {
|
||
break;
|
||
};
|
||
// Analytic description and normal sign of each face on a revolution.
|
||
let info: Vec<Option<(AnalyticKind, f64)>> = faces
|
||
.iter()
|
||
.map(|f| {
|
||
let fe = ex.get(*f)?;
|
||
if !matches!(fe.name(), "FACE_SURFACE" | "ADVANCED_FACE") {
|
||
return None;
|
||
}
|
||
let sid = fe.params().get(2)?.as_ref_id()?;
|
||
let an = (*cache.entry(sid).or_insert_with(|| {
|
||
let se = ex.get(sid)?;
|
||
match se.name() {
|
||
"SURFACE_OF_REVOLUTION" => analytic_revolution(ex, se),
|
||
// Coplanar pieces (a face split where a mirrored half was glued on).
|
||
"PLANE" => {
|
||
let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };
|
||
let f = crate::step_in::geom::frame(&cx, se.params().get(1)?.as_ref_id()?).ok()?;
|
||
let v = |a: truck_modeling::Vector3| [a.x, a.y, a.z];
|
||
Some(Analytic { kind: AnalyticKind::Plane { o: [f.o.x, f.o.y, f.o.z], z: v(f.z), x: v(f.x) }, flip: false })
|
||
}
|
||
// Pieces of a B-spline cylinder or cone merge only when their edges
|
||
// are circles square to the axis and rulings (an extruded hole).
|
||
_ => analytic_bspline(ex, se).filter(|a| match a.kind {
|
||
AnalyticKind::Cylinder { .. } | AnalyticKind::Cone { .. } => square_or_ruled(ex, fe, &a.kind),
|
||
_ => true,
|
||
}),
|
||
}
|
||
}))?;
|
||
let sense = fe.params().get(3)?.as_bool()?;
|
||
let z = match an.kind {
|
||
AnalyticKind::Plane { z, .. } => z,
|
||
_ => [0.0; 3],
|
||
};
|
||
let sign = face_normal_sign(&an.kind, z, an.flip, sense);
|
||
// Planes: normalise to one written direction for comparisons.
|
||
Some((an.kind, sign))
|
||
})
|
||
.collect();
|
||
let mut merged = false;
|
||
'pairs: for i in 0..faces.len() {
|
||
for j in (i + 1)..faces.len() {
|
||
let (Some(Some((ka, sa))), Some(Some((kb, sb)))) = (info.get(i), info.get(j)) else { continue };
|
||
if !same_analytic(ka, kb) {
|
||
continue;
|
||
}
|
||
let plane_dir = |k: &AnalyticKind| match k {
|
||
AnalyticKind::Plane { z, .. } => *z,
|
||
_ => [0.0, 0.0, 1.0],
|
||
};
|
||
let (na, nb) = (mul(plane_dir(ka), *sa), mul(plane_dir(kb), *sb));
|
||
if dot(na, nb) <= 0.0 {
|
||
continue;
|
||
}
|
||
let (Some(&fa), Some(&fb)) = (faces.get(i), faces.get(j)) else { continue };
|
||
// Faces of different colours stay apart.
|
||
if paint.get(&fa) != paint.get(&fb) {
|
||
continue;
|
||
}
|
||
let (Some(ea), Some(eb)) = (ex.get(fa).and_then(|f| face_edges(ex, f)), ex.get(fb).and_then(|f| face_edges(ex, f))) else {
|
||
continue;
|
||
};
|
||
let all: Vec<(u64, bool)> = ea.into_iter().chain(eb).flatten().collect();
|
||
let shared: std::collections::HashSet<u64> =
|
||
all.iter().filter(|(e, d)| all.iter().any(|(e2, d2)| e2 == e && d2 != d)).map(|(e, _)| *e).collect();
|
||
if shared.is_empty() || shared.iter().any(|e| on_split(ex, *e)) {
|
||
continue;
|
||
}
|
||
// Chain oriented edges into loops by vertices (None: they do not close).
|
||
let ends = |(e, d): (u64, bool)| -> Option<(u64, u64)> {
|
||
let p = ex.get(e)?.params();
|
||
let (s0, s1) = (p.get(1)?.as_ref_id()?, p.get(2)?.as_ref_id()?);
|
||
Some(if d { (s0, s1) } else { (s1, s0) })
|
||
};
|
||
let chain = |mut pool: Vec<(u64, bool)>| -> Option<Vec<Vec<(u64, bool)>>> {
|
||
let mut loops = Vec::new();
|
||
while let Some(first) = pool.pop() {
|
||
let (start, mut at) = ends(first)?;
|
||
let mut lp = vec![first];
|
||
while at != start {
|
||
if lp.len() > 100_000 {
|
||
return None;
|
||
}
|
||
let k = pool.iter().position(|x| ends(*x).is_some_and(|(s, _)| s == at))?;
|
||
let x = pool.remove(k);
|
||
at = ends(x)?.1;
|
||
lp.push(x);
|
||
}
|
||
loops.push(lp);
|
||
}
|
||
Some(loops)
|
||
};
|
||
// A full turn keeps one shared edge as the face's seam, used both ways (as other
|
||
// systems write cylinders and cone tips); otherwise the shared edges go.
|
||
// (A horn torus band needs no seam: its rings meet at the pole.)
|
||
let mut loops = None;
|
||
if shared.len() >= 2 && !matches!(ka, AnalyticKind::HornTorus { .. } | AnalyticKind::Plane { .. }) {
|
||
// Without the shared edges: one ring (a cone tip) or two (a band). The seam
|
||
// runs from a vertex on the first ring to the second ring (or the apex) and
|
||
// back: ring A, seam, ring B, seam reversed.
|
||
let rest: Vec<(u64, bool)> = all.iter().copied().filter(|(e, _)| !shared.contains(e)).collect();
|
||
if let Some(rings) = chain(rest).filter(|r| matches!(r.len(), 1 | 2)) {
|
||
let starts_at = |ring: &Vec<(u64, bool)>, v: u64| ring.iter().position(|x| ends(*x).is_some_and(|(a, _)| a == v));
|
||
let on_axis = |v: u64| {
|
||
let (o, z) = match ka {
|
||
AnalyticKind::Cone { o, z, .. } | AnalyticKind::Sphere { o, z, .. } => (*o, *z),
|
||
_ => return false,
|
||
};
|
||
vertex_point(ex, v).is_some_and(|q| norm(cross(sub(q, o), z)) <= 1e-6 * (1.0 + norm(q)))
|
||
};
|
||
let rotated =
|
||
|ring: &Vec<(u64, bool)>, k: usize| ring.iter().skip(k).chain(ring.iter().take(k)).copied().collect::<Vec<_>>();
|
||
// Whether a ring leaves its first vertex turning anticlockwise about a
|
||
// cylinder's or cone's axis (the way its angle parameter grows).
|
||
let turns_with_angle = |ring: &[(u64, bool)]| -> Option<bool> {
|
||
let (o, z) = match ka {
|
||
AnalyticKind::Cylinder { o, z, .. } | AnalyticKind::Cone { o, z, .. } => (*o, *z),
|
||
_ => return None,
|
||
};
|
||
let &(edge, dir) = ring.first()?;
|
||
let start = vertex_point(ex, ends((edge, dir))?.0)?;
|
||
let mut pts = edge_points(ex, edge, 4)?;
|
||
if ex.get(edge)?.params().get(4)?.as_bool()? != dir {
|
||
pts.reverse();
|
||
}
|
||
let radial = |q: V3| {
|
||
let v = sub(q, o);
|
||
sub(v, mul(z, dot(v, z)))
|
||
};
|
||
let turn = dot(cross(radial(start), radial(*pts.get(1)?)), z);
|
||
(turn != 0.0).then_some(turn > 0.0)
|
||
};
|
||
let mut cands: Vec<u64> = shared.iter().copied().collect();
|
||
cands.sort();
|
||
'seam: for keep in cands {
|
||
for &(e, d) in all.iter().filter(|(e, _)| *e == keep) {
|
||
let Some((a, b)) = ends((e, d)) else { continue };
|
||
let (Some(ra), Some(ka0)) = (rings.first(), rings.first().and_then(|r| starts_at(r, a))) else { continue };
|
||
let mut lp = rotated(ra, ka0);
|
||
let mut back = (e, !d);
|
||
match rings.get(1) {
|
||
Some(rb) => {
|
||
let Some(kb) = starts_at(rb, b) else { continue };
|
||
let ring_b = rotated(rb, kb);
|
||
// Readers put a seam's first use on the side where the
|
||
// angle starts, so the ring after it must turn the way
|
||
// the angle grows; else that ring and the seam's other
|
||
// use go first (#3394).
|
||
if turns_with_angle(&ring_b) == Some(false) {
|
||
let ring_a = std::mem::replace(&mut lp, ring_b);
|
||
lp.push((e, !d));
|
||
lp.extend(ring_a);
|
||
back = (e, d);
|
||
} else {
|
||
lp.push((e, d));
|
||
lp.extend(ring_b);
|
||
}
|
||
}
|
||
// A cone tip (or a sphere's pole cap): the seam's far end is
|
||
// the apex on the axis, off the ring.
|
||
None if starts_at(ra, b).is_none() && on_axis(b) => lp.push((e, d)),
|
||
None => continue,
|
||
}
|
||
lp.push(back);
|
||
loops = Some(vec![lp]);
|
||
break 'seam;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let planar = matches!(ka, AnalyticKind::Plane { .. });
|
||
if loops.is_none() && planar {
|
||
// A plane needs no seam: an annulus keeps its two rings, a face with a hole
|
||
// its hole. The largest loop goes first (the outer bound).
|
||
let rest: Vec<(u64, bool)> = all.iter().copied().filter(|(e, _)| !shared.contains(e)).collect();
|
||
loops = chain(rest).map(|mut l| {
|
||
let size = |lp: &Vec<(u64, bool)>| {
|
||
let pts: Vec<V3> = lp.iter().filter_map(|x| ends(*x).and_then(|(a, _)| vertex_point(ex, a))).collect();
|
||
let mut lo = [f64::INFINITY; 3];
|
||
let mut hi = [f64::NEG_INFINITY; 3];
|
||
for p in &pts {
|
||
for k in 0..3 {
|
||
lo[k] = lo[k].min(p[k]);
|
||
hi[k] = hi[k].max(p[k]);
|
||
}
|
||
}
|
||
norm(sub(hi, lo))
|
||
};
|
||
l.sort_by(|a, b| size(b).total_cmp(&size(a)));
|
||
l
|
||
});
|
||
}
|
||
if loops.is_none() && !planar {
|
||
let rest: Vec<(u64, bool)> = all.iter().copied().filter(|(e, _)| !shared.contains(e)).collect();
|
||
loops = chain(rest)
|
||
.map(|mut l| {
|
||
// Rings meeting at a vertex (both ends of a horn torus band meet at
|
||
// its pole) form one figure-eight loop through it.
|
||
while l.len() > 1 {
|
||
let Some(second) = l.pop() else { break };
|
||
let at = l.iter().enumerate().find_map(|(li, lp)| {
|
||
lp.iter().enumerate().find_map(|(k, x)| {
|
||
let v = ends(*x)?.1;
|
||
let s = second.iter().position(|y| ends(*y).is_some_and(|(a, _)| a == v))?;
|
||
Some((li, k, s))
|
||
})
|
||
});
|
||
let Some((li, k, s)) = at else {
|
||
l.push(second);
|
||
break;
|
||
};
|
||
let mut second = second;
|
||
second.rotate_left(s);
|
||
if let Some(lp) = l.get_mut(li) {
|
||
for (n, x) in second.into_iter().enumerate() {
|
||
lp.insert(k + 1 + n, x);
|
||
}
|
||
}
|
||
}
|
||
l
|
||
})
|
||
.filter(|l| l.len() == 1);
|
||
}
|
||
let Some(loops) = loops else { continue };
|
||
// A loop of seams only (a whole sphere) bounds nothing: keep the faces apart.
|
||
if loops.iter().all(|l| l.iter().all(|(e, _)| l.iter().filter(|(e2, _)| e2 == e).count() > 1)) {
|
||
continue;
|
||
}
|
||
// Write the merged face.
|
||
let mut bounds = Vec::new();
|
||
for lp in loops {
|
||
let mut oes = Vec::new();
|
||
for (e, d) in lp {
|
||
let id = next;
|
||
next += 1;
|
||
ex.entities.insert(
|
||
id,
|
||
p21::Entity {
|
||
records: vec![p21::Record {
|
||
name: "ORIENTED_EDGE".into(),
|
||
params: vec![
|
||
Param::Str(String::new()),
|
||
Param::Derived,
|
||
Param::Derived,
|
||
Param::Ref(e),
|
||
Param::Enum(if d { "T" } else { "F" }.into()),
|
||
],
|
||
}],
|
||
},
|
||
);
|
||
oes.push(Param::Ref(id));
|
||
}
|
||
let lid = next;
|
||
next += 1;
|
||
ex.entities.insert(
|
||
lid,
|
||
p21::Entity {
|
||
records: vec![p21::Record { name: "EDGE_LOOP".into(), params: vec![Param::Str(String::new()), Param::List(oes)] }],
|
||
},
|
||
);
|
||
let bid = next;
|
||
next += 1;
|
||
ex.entities.insert(
|
||
bid,
|
||
p21::Entity {
|
||
records: vec![p21::Record {
|
||
name: "FACE_BOUND".into(),
|
||
params: vec![Param::Str(String::new()), Param::Ref(lid), Param::Enum("T".into())],
|
||
}],
|
||
},
|
||
);
|
||
bounds.push(Param::Ref(bid));
|
||
}
|
||
let Some(old) = ex.get(fa).cloned() else { continue };
|
||
let mut params = old.params().to_vec();
|
||
if let Some(slot) = params.get_mut(1) {
|
||
*slot = Param::List(bounds);
|
||
}
|
||
let nid = next;
|
||
next += 1;
|
||
if let Some(sid) = params.get(2).and_then(Param::as_ref_id) {
|
||
merged_surfaces.insert(sid);
|
||
}
|
||
ex.entities.insert(nid, p21::Entity { records: vec![p21::Record { name: old.name().to_string(), params }] });
|
||
if let Some(look) = paint.remove(&fa) {
|
||
paint.remove(&fb);
|
||
paint.insert(nid, look);
|
||
}
|
||
let new_list: Vec<Param> = faces.iter().filter(|f| **f != fb).map(|f| Param::Ref(if *f == fa { nid } else { *f })).collect();
|
||
if let Some(she) = ex.entities.get_mut(&sh)
|
||
&& let Some(r) = she.records.first_mut()
|
||
&& let Some(slot) = r.params.get_mut(1)
|
||
{
|
||
*slot = Param::List(new_list);
|
||
}
|
||
merged = true;
|
||
break 'pairs;
|
||
}
|
||
}
|
||
if !merged {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
merged_surfaces
|
||
}
|
||
|
||
/// B-spline cylinder and cone sheets written as CYLINDRICAL_SURFACE and CONICAL_SURFACE (the
|
||
/// sheet covers only its own piece, and a fillet's may reach far past it), with the direction of
|
||
/// the parameter seam: on the face's seam edge for a full turn, else in the middle of the gap the
|
||
/// face leaves (`gap_middle`), else opposite the face's middle.
|
||
/// Sheets under faces merged from pieces always; a lone piece when its edges are circles square
|
||
/// to the axis and rulings. (Faces replaced by merges stay in the exchange unreferenced: only the
|
||
/// shells' faces count.)
|
||
fn analytic_sheets(ex: &p21::Exchange, merged_surfaces: &std::collections::HashSet<u64>) -> HashMap<u64, V3> {
|
||
let live: Vec<u64> = ex
|
||
.entities
|
||
.values()
|
||
.filter_map(|e| if matches!(e.name(), "CLOSED_SHELL" | "OPEN_SHELL") { e.params().get(1).and_then(Param::as_list) } else { None })
|
||
.flatten()
|
||
.filter_map(Param::as_ref_id)
|
||
.collect();
|
||
let mut out = HashMap::new();
|
||
for e in live.iter().filter_map(|f| ex.get(*f)) {
|
||
let Some(sid) = e.params().get(2).and_then(Param::as_ref_id) else { continue };
|
||
if out.contains_key(&sid) {
|
||
continue;
|
||
}
|
||
let Some(Analytic { kind, .. }) = ex.get(sid).and_then(|se| ruled_bspline(ex, se)) else {
|
||
continue;
|
||
};
|
||
let (AnalyticKind::Cylinder { o, z, .. } | AnalyticKind::Cone { o, z, .. }) = kind else { continue };
|
||
if !merged_surfaces.contains(&sid) && !square_or_ruled(ex, e, &kind) {
|
||
continue;
|
||
}
|
||
let Some(loops) = face_edges(ex, e) else { continue };
|
||
let radial = |q: V3| {
|
||
let v = sub(q, o);
|
||
sub(v, mul(z, dot(v, z)))
|
||
};
|
||
let seam = loops
|
||
.iter()
|
||
.flat_map(|l| l.iter().map(move |(x, _)| (l, *x)))
|
||
.find(|(l, x)| l.iter().filter(|(y, _)| y == x).count() > 1)
|
||
.map(|(_, x)| x);
|
||
// (A cone tip's seam has one end at the apex, on the axis.)
|
||
let seam_dir = seam.and_then(|edge| {
|
||
let p = ex.get(edge)?.params();
|
||
[p.get(1), p.get(2)].into_iter().filter_map(|v| vertex_point(ex, v?.as_ref_id()?)).find_map(|q| unit(radial(q)))
|
||
});
|
||
let x = match seam_dir.or_else(|| gap_middle(ex, &loops, z, &radial)) {
|
||
Some(x) => Some(x),
|
||
None => {
|
||
// No single gap to find (a half turn has two corners, a tube cut in pieces
|
||
// several). Points along the edges, not just their ends: the corners of a half
|
||
// turn (a slot's round end) point both ways and cancel out (#1198). The sheet's
|
||
// own middle where even those do.
|
||
let mean = loops
|
||
.iter()
|
||
.flatten()
|
||
.filter_map(|(edge, _)| edge_samples(ex, *edge))
|
||
.flatten()
|
||
.filter_map(|q| unit(radial(q)))
|
||
.fold([0.0; 3], add);
|
||
let (AnalyticKind::Cylinder { x: middle, .. } | AnalyticKind::Cone { x: middle, .. }) = kind else { continue };
|
||
Some(unit(mul(mean, -1.0)).unwrap_or(middle))
|
||
}
|
||
};
|
||
if let Some(x) = x {
|
||
out.insert(sid, x);
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// The middle of the one angular gap that a face on a cylinder or cone leaves around its axis
|
||
/// `z`. The face's boundary vertices are sorted by angle; each two neighbours are joined by one
|
||
/// of its edges except across the gap (a 270° face split at 0°, 90°, 180° and 270° leaves
|
||
/// 270°–360°). None unless there are three angles or more and exactly one gap: two vertices can
|
||
/// be joined either way round.
|
||
fn gap_middle(ex: &p21::Exchange, loops: &[Vec<(u64, bool)>], z: V3, radial: &impl Fn(V3) -> V3) -> Option<V3> {
|
||
use std::f64::consts::TAU;
|
||
let mut edges: Vec<(V3, V3)> = Vec::new();
|
||
for (e, _) in loops.iter().flatten() {
|
||
let p = ex.get(*e)?.params();
|
||
let (a, b) = (vertex_point(ex, p.get(1)?.as_ref_id()?)?, vertex_point(ex, p.get(2)?.as_ref_id()?)?);
|
||
edges.push((unit(radial(a))?, unit(radial(b))?));
|
||
}
|
||
let e1 = edges.first()?.0;
|
||
let e2 = unit(cross(z, e1))?;
|
||
let angle = |d: V3| dot(d, e2).atan2(dot(d, e1)).rem_euclid(TAU);
|
||
let close = |a: f64, b: f64| {
|
||
let d = (a - b).rem_euclid(TAU);
|
||
d < 1e-6 || TAU - d < 1e-6
|
||
};
|
||
let mut angles: Vec<f64> = Vec::new();
|
||
for (a, b) in &edges {
|
||
for t in [angle(*a), angle(*b)] {
|
||
if !angles.iter().any(|s| close(*s, t)) {
|
||
angles.push(t);
|
||
}
|
||
}
|
||
}
|
||
if angles.len() < 3 {
|
||
return None;
|
||
}
|
||
angles.sort_by(f64::total_cmp);
|
||
let joined = |s: f64, t: f64| {
|
||
edges.iter().any(|(a, b)| {
|
||
let (x, y) = (angle(*a), angle(*b));
|
||
(close(x, s) && close(y, t)) || (close(x, t) && close(y, s))
|
||
})
|
||
};
|
||
let n = angles.len();
|
||
let gaps: Vec<(f64, f64)> = (0..n).filter_map(|i| Some((*angles.get(i)?, *angles.get((i + 1) % n)?))).filter(|(s, t)| !joined(*s, *t)).collect();
|
||
let [(s, t)] = gaps[..] else { return None };
|
||
let m = s + (t - s).rem_euclid(TAU) / 2.0;
|
||
unit(add(mul(e1, m.cos()), mul(e2, m.sin())))
|
||
}
|
||
|
||
/// Margin left round a face when its sheet is cut down to it, as a share of the face's own
|
||
/// parameter range on each side.
|
||
const SHEET_MARGIN: f64 = 0.02;
|
||
|
||
/// B-spline sheets that reach well past the one face on them, cut down to that face's parameter
|
||
/// range (and a margin), so readers bound the part by its faces (#1198): a round's sheet runs on
|
||
/// past both ends of the edge it rounds, and when a later cut crosses the round, the crossing edge
|
||
/// keeps it from being written as a cylinder (see `square_or_ruled`). Sheets written as analytic
|
||
/// surfaces, flat ones, sheets under several faces, and those whose face's edges do not all lie
|
||
/// on the piece cut out (a face across a closed sheet's seam) are left alone.
|
||
fn trimmed_sheets(ex: &p21::Exchange, analytic: &HashMap<u64, V3>) -> HashMap<u64, truck_modeling::Surface> {
|
||
let live: Vec<u64> = ex
|
||
.entities
|
||
.values()
|
||
.filter_map(|e| if matches!(e.name(), "CLOSED_SHELL" | "OPEN_SHELL") { e.params().get(1).and_then(Param::as_list) } else { None })
|
||
.flatten()
|
||
.filter_map(Param::as_ref_id)
|
||
.collect();
|
||
let mut users: HashMap<u64, usize> = HashMap::new();
|
||
for e in live.iter().filter_map(|f| ex.get(*f)) {
|
||
if let Some(sid) = e.params().get(2).and_then(Param::as_ref_id) {
|
||
*users.entry(sid).or_default() += 1;
|
||
}
|
||
}
|
||
let mut out = HashMap::new();
|
||
for e in live.iter().filter_map(|f| ex.get(*f)) {
|
||
let Some(sid) = e.params().get(2).and_then(Param::as_ref_id) else { continue };
|
||
if users.get(&sid) != Some(&1) || analytic.contains_key(&sid) {
|
||
continue;
|
||
}
|
||
let Some(se) = ex.get(sid) else { continue };
|
||
if !(se.has("B_SPLINE_SURFACE") || se.name() == "B_SPLINE_SURFACE_WITH_KNOTS") || planar_bspline(ex, se).is_some() {
|
||
continue;
|
||
}
|
||
let Some(pts) = face_edges(ex, e).and_then(|ls| ls.iter().flatten().map(|(x, _)| edge_points(ex, *x, 16)).collect::<Option<Vec<_>>>()) else {
|
||
continue;
|
||
};
|
||
let pts: Vec<V3> = pts.into_iter().flatten().collect();
|
||
let cx = crate::step_in::Ctx { ex, len: 1.0, ang: 1.0, tol: 1e-6, snap: 1e-6 };
|
||
let Ok(sheet) = crate::step_in::geom::bspline_surface(&cx, se) else { continue };
|
||
if let Ok(Some(cut)) = crate::guard("STEP sheet trim", || Ok(trim_sheet(&sheet, &pts))) {
|
||
out.insert(sid, cut);
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// `sheet` cut down to the parameter range `pts` (points on it) cover, with [`SHEET_MARGIN`];
|
||
/// `None` when that would not make it much smaller, or when a point is not on the piece cut out.
|
||
fn trim_sheet(sheet: &truck_modeling::Surface, pts: &[V3]) -> Option<truck_modeling::Surface> {
|
||
use truck_modeling::{ParametricSurface, SearchNearestParameter, Surface};
|
||
let (Some((u0, u1)), Some((v0, v1))) = sheet.try_range_tuple() else { return None };
|
||
// Edges made by intersecting surfaces are fitted to them, a micron or so off the sheet; a
|
||
// point on the wrong piece of it is far further.
|
||
let (lo, hi) = pts.iter().fold(([f64::INFINITY; 3], [f64::NEG_INFINITY; 3]), |(lo, hi), p| {
|
||
([lo[0].min(p[0]), lo[1].min(p[1]), lo[2].min(p[2])], [hi[0].max(p[0]), hi[1].max(p[1]), hi[2].max(p[2])])
|
||
});
|
||
let tol = 1e-3 + 1e-4 * norm(sub(hi, lo));
|
||
let near = |s: &Surface, p: V3| -> Option<(f64, f64)> {
|
||
let q = truck_modeling::Point3::new(p[0], p[1], p[2]);
|
||
let (u, v) = s.search_nearest_parameter(q, None, 100)?;
|
||
let r = s.subs(u, v);
|
||
(norm(sub([r.x, r.y, r.z], p)) <= tol).then_some((u, v))
|
||
};
|
||
let (mut ua, mut ub, mut va, mut vb) = (f64::INFINITY, f64::NEG_INFINITY, f64::INFINITY, f64::NEG_INFINITY);
|
||
for p in pts {
|
||
let (u, v) = near(sheet, *p)?;
|
||
(ua, ub, va, vb) = (ua.min(u), ub.max(u), va.min(v), vb.max(v));
|
||
}
|
||
let (du, dv) = ((ub - ua) * SHEET_MARGIN, (vb - va) * SHEET_MARGIN);
|
||
let (ua, ub, va, vb) = ((ua - du).max(u0), (ub + du).min(u1), (va - dv).max(v0), (vb + dv).min(v1));
|
||
// Worth it only where a parameter keeps less than four fifths of its range.
|
||
let keeps = |a: f64, b: f64, lo: f64, hi: f64| (b - a) / (hi - lo);
|
||
if !(ua < ub && va < vb) || (keeps(ua, ub, u0, u1) > 0.8 && keeps(va, vb, v0, v1) > 0.8) {
|
||
return None;
|
||
}
|
||
// The piece between the new ends: `ucut` keeps what lies before the cut and returns the rest.
|
||
macro_rules! cut {
|
||
($s:expr) => {{
|
||
let mut s = $s.clone();
|
||
if ua > u0 {
|
||
s = s.ucut(ua);
|
||
}
|
||
if ub < u1 {
|
||
s.ucut(ub);
|
||
}
|
||
if va > v0 {
|
||
s = s.vcut(va);
|
||
}
|
||
if vb < v1 {
|
||
s.vcut(vb);
|
||
}
|
||
s
|
||
}};
|
||
}
|
||
let piece = match sheet {
|
||
Surface::BSplineSurface(b) => Surface::BSplineSurface(cut!(b)),
|
||
Surface::NurbsSurface(n) => Surface::NurbsSurface(cut!(n)),
|
||
_ => return None,
|
||
};
|
||
pts.iter().all(|p| near(&piece, *p).is_some()).then_some(piece)
|
||
}
|
||
|
||
/// The B-rep entities of one body as truck writes them, parsed, the B-spline sheets to write
|
||
/// as cylinders and cones (see `analytic_sheets`) and those to write cut down to their faces
|
||
/// (see `trimmed_sheets`). Without `merge` the file is truck's, as is.
|
||
fn brep_exchange(b: &Body, merge: bool) -> Result<(p21::Exchange, HashMap<u64, V3>, HashMap<u64, truck_modeling::Surface>, HashMap<u64, FaceLook>)> {
|
||
let text = crate::step::truck_step(&[b], "SolidCraft")?;
|
||
let mut ex = p21::parse(&text).map_err(|e| KernelError::Failed(format!("STEP export: {e}")))?;
|
||
collapse_short_edges(&mut ex);
|
||
// Face colours by exchange face: truck writes each shell's faces in the body's face order.
|
||
let mut paint = HashMap::new();
|
||
if let Some(p) = b.paint()
|
||
&& !p.faces.is_empty()
|
||
{
|
||
let mut shells: Vec<u64> = ex.entities.iter().filter(|(_, e)| matches!(e.name(), "CLOSED_SHELL" | "OPEN_SHELL")).map(|(i, _)| *i).collect();
|
||
shells.sort();
|
||
let faces: Vec<u64> = shells.iter().filter_map(|s| ex.get(*s)?.params().get(1)?.as_list()).flatten().filter_map(Param::as_ref_id).collect();
|
||
for f in &p.faces {
|
||
if let Some(id) = faces.get(f.face) {
|
||
paint.insert(*id, (f.color, f.opacity));
|
||
}
|
||
}
|
||
}
|
||
let before = shell_face_count(&ex);
|
||
let keep = b.split_lines().map(|l| l.as_slice()).unwrap_or(&[]);
|
||
let (sheets, trimmed) = if merge {
|
||
let merged = merge_split_faces(&mut ex, &mut paint, keep);
|
||
let sheets = analytic_sheets(&ex, &merged);
|
||
let trimmed = trimmed_sheets(&ex, &sheets);
|
||
// Lone sheets rewritten as analytic surfaces, or cut down, count as changes to check too.
|
||
MERGES.with(|m| m.set(m.get() + sheets.keys().filter(|s| !merged.contains(s)).count() + trimmed.len()));
|
||
(sheets, trimmed)
|
||
} else {
|
||
Default::default()
|
||
};
|
||
MERGES.with(|m| m.set(m.get() + before.saturating_sub(shell_face_count(&ex))));
|
||
Ok((ex, sheets, trimmed, paint))
|
||
}
|
||
|
||
/// The separate pieces of a body for export, each keeping its face colours: a body of several
|
||
/// lumps (a plate and the islands a cut left inside its holes, such as letter counters) is
|
||
/// several solids, never one solid whose other pieces are written as voids. A body in one
|
||
/// piece, or one whose pieces cannot be told apart, is itself.
|
||
fn export_lumps(b: &Body) -> Vec<Body> {
|
||
if b.mesh.is_some() || b.solid.boundaries().len() < 2 {
|
||
return vec![b.clone()];
|
||
}
|
||
let lumps = match b.lumps() {
|
||
Ok(l) if l.len() > 1 => l,
|
||
_ => return vec![b.clone()],
|
||
};
|
||
let index: HashMap<_, usize> = b.solid.face_iter().enumerate().map(|(i, f)| (f.id(), i)).collect();
|
||
lumps
|
||
.into_iter()
|
||
.map(|lump| {
|
||
let paint = b.paint().map(|p| crate::body::Paint {
|
||
opacity: p.opacity,
|
||
faces: lump
|
||
.solid
|
||
.face_iter()
|
||
.enumerate()
|
||
.filter_map(|(k, f)| {
|
||
let i = index.get(&f.id())?;
|
||
p.faces.iter().find(|fp| fp.face == *i).map(|fp| crate::body::FacePaint { face: k, ..fp.clone() })
|
||
})
|
||
.collect(),
|
||
});
|
||
lump.with_color(b.color()).with_split_lines(b.split_lines().cloned()).with_paint(paint)
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// Faces in the exchange's shells (fewer after merging).
|
||
fn shell_face_count(ex: &p21::Exchange) -> usize {
|
||
ex.entities
|
||
.values()
|
||
.filter(|e| matches!(e.name(), "CLOSED_SHELL" | "OPEN_SHELL"))
|
||
.filter_map(|e| e.params().get(1).and_then(Param::as_list))
|
||
.map(<[Param]>::len)
|
||
.sum()
|
||
}
|
||
|
||
/// A face's own colour (0..1) and opacity.
|
||
type FaceLook = ([f32; 3], f32);
|
||
|
||
fn rigid_frame(m: &[[f64; 4]; 4]) -> Result<([f64; 3], [f64; 3], [f64; 3])> {
|
||
let x = [m[0][0], m[0][1], m[0][2]];
|
||
let y = [m[1][0], m[1][1], m[1][2]];
|
||
let z = [m[2][0], m[2][1], m[2][2]];
|
||
let dot = |a: [f64; 3], b: [f64; 3]| a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
||
let cross = [x[1] * y[2] - x[2] * y[1], x[2] * y[0] - x[0] * y[2], x[0] * y[1] - x[1] * y[0]];
|
||
let ok = (dot(x, x) - 1.0).abs() < 1e-6 && (dot(y, y) - 1.0).abs() < 1e-6 && dot(x, y).abs() < 1e-6 && dot(cross, z) > 0.999_999;
|
||
if !ok || m.iter().flatten().any(|v| !v.is_finite()) {
|
||
return Err(KernelError::Invalid("component placements must be rigid (rotation and translation) to export as STEP".into()));
|
||
}
|
||
Ok(([m[3][0], m[3][1], m[3][2]], z, x))
|
||
}
|
||
|
||
/// STEP text (AP242) for products with bodies and assembly placements; `root` is the top product.
|
||
pub fn step_export_products(products: &[ExportProduct], root: usize, header: &StepHeader) -> Result<String> {
|
||
MERGES.with(|m| m.set(0));
|
||
let text = products_text(products, root, header, true)?;
|
||
// Faces merged per surface, and sheets rewritten as cylinders and cones, must read back as
|
||
// cleanly as truck's pieces (a merge can leave a loop the reader cannot lay out); otherwise
|
||
// the pieces are written as truck made them. Without a change there is nothing to check.
|
||
let clean = |t: &str| crate::step_in::step_import(t).is_ok_and(|i| i.warnings.is_empty());
|
||
if MERGES.with(|m| m.get()) > 0 && !clean(&text) {
|
||
let plain = products_text(products, root, header, false)?;
|
||
if clean(&plain) {
|
||
return Ok(plain);
|
||
}
|
||
}
|
||
Ok(text)
|
||
}
|
||
|
||
thread_local! {
|
||
/// Faces merged and sheets rewritten while writing the current export.
|
||
static MERGES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||
}
|
||
|
||
fn products_text(products: &[ExportProduct], root: usize, header: &StepHeader, merge: bool) -> Result<String> {
|
||
if products.is_empty() || root >= products.len() {
|
||
return Err(KernelError::Invalid("nothing to export".into()));
|
||
}
|
||
if products.iter().all(|p| p.bodies.is_empty()) {
|
||
return Err(KernelError::Invalid("nothing to export".into()));
|
||
}
|
||
for p in products {
|
||
for b in &p.bodies {
|
||
b.body.require_brep("STEP export")?;
|
||
}
|
||
if p.children.iter().any(|(c, _, _)| *c >= products.len()) {
|
||
return Err(KernelError::Invalid("bad component reference".into()));
|
||
}
|
||
}
|
||
// No product may contain itself.
|
||
fn cyclic(products: &[ExportProduct], p: usize, stack: &mut Vec<usize>) -> bool {
|
||
if stack.contains(&p) || stack.len() > 64 {
|
||
return true;
|
||
}
|
||
stack.push(p);
|
||
let bad = products.get(p).is_some_and(|x| x.children.iter().any(|(c, _, _)| cyclic(products, *c, stack)));
|
||
stack.pop();
|
||
bad
|
||
}
|
||
if cyclic(products, root, &mut Vec::new()) {
|
||
return Err(KernelError::Invalid("the component tree is recursive".into()));
|
||
}
|
||
|
||
let mut o = Out::default();
|
||
let app = o.add("APPLICATION_CONTEXT('managed model based 3d engineering')");
|
||
o.add(format!("APPLICATION_PROTOCOL_DEFINITION('international standard','ap242_managed_model_based_3d_engineering',2014,#{app})"));
|
||
let pctx = o.add(format!("PRODUCT_CONTEXT('',#{app},'mechanical')"));
|
||
let pdctx = o.add(format!("PRODUCT_DEFINITION_CONTEXT('part definition',#{app},'design')"));
|
||
let mm = o.add("(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.))");
|
||
let rad = o.add("(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.))");
|
||
let sr = o.add("(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT())");
|
||
let unc = o.add(format!("UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-06),#{mm},'distance_accuracy_value','confusion accuracy')"));
|
||
let ctx = o.add(format!(
|
||
"(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#{unc}))GLOBAL_UNIT_ASSIGNED_CONTEXT((#{mm},#{rad},#{sr}))REPRESENTATION_CONTEXT('Context #1','3D Context with UNIT and UNCERTAINTY'))"
|
||
));
|
||
let origin = o.placement([0.0; 3], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]);
|
||
|
||
// Products (only those reachable from the root).
|
||
let mut reach = vec![false; products.len()];
|
||
let mut todo = vec![root];
|
||
while let Some(p) = todo.pop() {
|
||
if let Some(r) = reach.get_mut(p)
|
||
&& !*r
|
||
{
|
||
*r = true;
|
||
if let Some(x) = products.get(p) {
|
||
todo.extend(x.children.iter().map(|(c, _, _)| *c));
|
||
}
|
||
}
|
||
}
|
||
let mut pd = vec![0u64; products.len()];
|
||
let mut shape_rep = vec![0u64; products.len()];
|
||
let mut product_ids = Vec::new();
|
||
let mut styled = Vec::new();
|
||
let mut child_items: Vec<Vec<u64>> = vec![Vec::new(); products.len()];
|
||
// Placements of children inside each parent, made before the parent's representation.
|
||
let mut placements: Vec<Vec<u64>> = vec![Vec::new(); products.len()];
|
||
for (pi, p) in products.iter().enumerate() {
|
||
if !reach.get(pi).copied().unwrap_or(false) {
|
||
continue;
|
||
}
|
||
for (_, m, _) in &p.children {
|
||
let (t, z, x) = rigid_frame(m)?;
|
||
let (pt, dz, dx) = (o.point(t), o.direction(z), o.direction(x));
|
||
// Its own entity: it is an item of the parent's representation.
|
||
let a = o.add(format!("AXIS2_PLACEMENT_3D('',#{pt},#{dz},#{dx})"));
|
||
if let Some(v) = placements.get_mut(pi) {
|
||
v.push(a);
|
||
}
|
||
if let Some(v) = child_items.get_mut(pi) {
|
||
v.push(a);
|
||
}
|
||
}
|
||
}
|
||
for (pi, p) in products.iter().enumerate() {
|
||
if !reach.get(pi).copied().unwrap_or(false) {
|
||
continue;
|
||
}
|
||
let name = if p.name.trim().is_empty() { "Part".to_string() } else { p.name.clone() };
|
||
let prod = o.add(format!("PRODUCT({},{},'',(#{pctx}))", string(&name), string(&name)));
|
||
product_ids.push(prod);
|
||
let pdf = o.add(format!("PRODUCT_DEFINITION_FORMATION('','',#{prod})"));
|
||
let d = o.add(format!("PRODUCT_DEFINITION('design','',#{pdf},#{pdctx})"));
|
||
let pds = o.add(format!("PRODUCT_DEFINITION_SHAPE('','',#{d})"));
|
||
let mut items = vec![origin];
|
||
items.extend(child_items.get(pi).cloned().unwrap_or_default());
|
||
let item_list = items.iter().map(|i| format!("#{i}")).collect::<Vec<_>>().join(",");
|
||
let srep = o.add(format!("SHAPE_REPRESENTATION({},({item_list}),#{ctx})", string(&name)));
|
||
o.add(format!("SHAPE_DEFINITION_REPRESENTATION(#{pds},#{srep})"));
|
||
if let Some(slot) = pd.get_mut(pi) {
|
||
*slot = d;
|
||
}
|
||
if let Some(slot) = shape_rep.get_mut(pi) {
|
||
*slot = srep;
|
||
}
|
||
if !p.bodies.is_empty() {
|
||
let mut solids = Vec::new();
|
||
for b in &p.bodies {
|
||
for lump in export_lumps(b.body) {
|
||
let (ex, merged, trimmed, face_paint) = brep_exchange(&lump, merge)?;
|
||
o.merged = merged;
|
||
o.trimmed = trimmed;
|
||
o.faces_out.clear();
|
||
let mut roots: Vec<u64> =
|
||
ex.entities.iter().filter(|(_, e)| matches!(e.name(), "MANIFOLD_SOLID_BREP" | "BREP_WITH_VOIDS")).map(|(i, _)| *i).collect();
|
||
roots.sort();
|
||
for r in roots {
|
||
let id = o.copy_solid(&ex, r, &b.name).map_err(|e| KernelError::Failed(format!("STEP export: {e}")))?;
|
||
solids.push(id);
|
||
let opacity = lump.paint().map(|p| p.opacity).unwrap_or(1.0);
|
||
if let Some(c) = b.color {
|
||
styled.push(style(&mut o, id, c, opacity));
|
||
}
|
||
}
|
||
// Faces with colours of their own.
|
||
let mut painted: Vec<(u64, ([f32; 3], f32))> =
|
||
face_paint.into_iter().filter_map(|(f, look)| Some((*o.faces_out.get(&f)?, look))).collect();
|
||
painted.sort_by_key(|(f, _)| *f);
|
||
for (f, (c, op)) in painted {
|
||
styled.push(style(&mut o, f, c, op));
|
||
}
|
||
}
|
||
}
|
||
let list = solids.iter().chain(std::iter::once(&origin)).map(|i| format!("#{i}")).collect::<Vec<_>>().join(",");
|
||
let absr = o.add(format!("ADVANCED_BREP_SHAPE_REPRESENTATION({},({list}),#{ctx})", string(&name)));
|
||
o.add(format!("SHAPE_REPRESENTATION_RELATIONSHIP('','',#{srep},#{absr})"));
|
||
}
|
||
}
|
||
if !product_ids.is_empty() {
|
||
let list = product_ids.iter().map(|i| format!("#{i}")).collect::<Vec<_>>().join(",");
|
||
o.add(format!("PRODUCT_RELATED_PRODUCT_CATEGORY('part','',({list}))"));
|
||
}
|
||
// Assembly occurrences.
|
||
for (pi, p) in products.iter().enumerate() {
|
||
if !reach.get(pi).copied().unwrap_or(false) {
|
||
continue;
|
||
}
|
||
for (k, (ci, _, oname)) in p.children.iter().enumerate() {
|
||
let (Some(&parent_pd), Some(&child_pd), Some(&parent_sr), Some(&child_sr), Some(&target)) =
|
||
(pd.get(pi), pd.get(*ci), shape_rep.get(pi), shape_rep.get(*ci), placements.get(pi).and_then(|v| v.get(k)))
|
||
else {
|
||
continue;
|
||
};
|
||
let nm = if oname.trim().is_empty() {
|
||
format!("{}:{}", products.get(*ci).map(|c| c.name.as_str()).unwrap_or(""), k + 1)
|
||
} else {
|
||
oname.clone()
|
||
};
|
||
let nauo = o.add(format!("NEXT_ASSEMBLY_USAGE_OCCURRENCE({},{},'',#{parent_pd},#{child_pd},$)", string(&nm), string(&nm)));
|
||
let pds = o.add(format!("PRODUCT_DEFINITION_SHAPE('','',#{nauo})"));
|
||
let idt = o.add(format!("ITEM_DEFINED_TRANSFORMATION('','',#{origin},#{target})"));
|
||
let rr = o.add(format!(
|
||
"(REPRESENTATION_RELATIONSHIP('','',#{child_sr},#{parent_sr})REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#{idt})SHAPE_REPRESENTATION_RELATIONSHIP())"
|
||
));
|
||
o.add(format!("CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#{rr},#{pds})"));
|
||
}
|
||
}
|
||
if !styled.is_empty() {
|
||
let list = styled.iter().map(|i| format!("#{i}")).collect::<Vec<_>>().join(",");
|
||
o.add(format!("MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',({list}),#{ctx})"));
|
||
}
|
||
|
||
let mut s = String::new();
|
||
s.push_str("ISO-10303-21;\nHEADER;\n");
|
||
let description = if header.description.is_empty() { "SolidCraft model" } else { header.description.as_str() };
|
||
let _ = writeln!(s, "FILE_DESCRIPTION(({}),'2;1');", string(description));
|
||
let _ = writeln!(
|
||
s,
|
||
"FILE_NAME({},{},({}),({}),'SolidCraft','SolidCraft','');",
|
||
string(&header.file_name),
|
||
string(&header.time_stamp),
|
||
string(&header.author),
|
||
string(&header.organization)
|
||
);
|
||
s.push_str("FILE_SCHEMA(('AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF { 1 0 10303 442 1 1 4 }'));\nENDSEC;\nDATA;\n");
|
||
for (i, l) in o.lines.iter().enumerate() {
|
||
let _ = writeln!(s, "#{}={l};", i + 1);
|
||
}
|
||
s.push_str("ENDSEC;\nEND-ISO-10303-21;\n");
|
||
Ok(s)
|
||
}
|
||
|
||
/// A surface colour for a solid (STYLED_ITEM chain).
|
||
fn style(o: &mut Out, item: u64, c: [f32; 3], opacity: f32) -> u64 {
|
||
let rgb = o.add_shared(format!("COLOUR_RGB('',{},{},{})", real(c[0] as f64), real(c[1] as f64), real(c[2] as f64)));
|
||
let fasc = o.add_shared(format!("FILL_AREA_STYLE_COLOUR('',#{rgb})"));
|
||
let fas = o.add_shared(format!("FILL_AREA_STYLE('',(#{fasc}))"));
|
||
let ssfa = o.add_shared(format!("SURFACE_STYLE_FILL_AREA(#{fas})"));
|
||
// See-through looks add a transparency (1 = invisible) to the side style.
|
||
let sides = if opacity < 1.0 {
|
||
let tr = o.add_shared(format!("SURFACE_STYLE_TRANSPARENT({})", real((1.0 - opacity as f64).clamp(0.0, 1.0))));
|
||
format!("#{ssfa},#{tr}")
|
||
} else {
|
||
format!("#{ssfa}")
|
||
};
|
||
let sss = o.add_shared(format!("SURFACE_SIDE_STYLE('',({sides}))"));
|
||
let ssu = o.add_shared(format!("SURFACE_STYLE_USAGE(.BOTH.,#{sss})"));
|
||
let psa = o.add_shared(format!("PRESENTATION_STYLE_ASSIGNMENT((#{ssu}))"));
|
||
o.add(format!("STYLED_ITEM('color',(#{psa}),#{item})"))
|
||
}
|
||
|
||
/// STEP text for bodies of one part (names `Body1`…).
|
||
pub fn step_export_bodies(bodies: &[ExportBody], header: &StepHeader) -> Result<String> {
|
||
let name = if header.file_name.is_empty() {
|
||
"Part".to_string()
|
||
} else {
|
||
header.file_name.trim_end_matches(".step").trim_end_matches(".stp").to_string()
|
||
};
|
||
let p = ExportProduct {
|
||
name,
|
||
bodies: bodies.iter().map(|b| ExportBody { name: b.name.clone(), body: b.body, color: b.color }).collect(),
|
||
children: Vec::new(),
|
||
};
|
||
step_export_products(&[p], 0, header)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn islands_are_solids_of_their_own_not_voids() {
|
||
use solidcraft_geom::{Loop2, Plane, Region2, Vec2};
|
||
let square = |a: f64, b: f64| Loop2::polygon(&[Vec2::new(a, a), Vec2::new(b, a), Vec2::new(b, b), Vec2::new(a, b)]);
|
||
// A plate with a square hole, and an island inside the hole (a letter's counter).
|
||
let plate = Region2 { outer: square(0.0, 30.0), holes: vec![square(10.0, 20.0).reversed()] };
|
||
let island = Region2 { outer: square(12.0, 18.0), holes: vec![] };
|
||
let body = crate::extrude_planar_regions(&Plane::XY, &[plate, island], 0.0, 2.0).unwrap();
|
||
assert_eq!(body.shell_count(), 2);
|
||
let text = crate::step_export(&[&body], "test").unwrap();
|
||
assert_eq!(text.matches("MANIFOLD_SOLID_BREP(").count(), 2, "{text}");
|
||
assert_eq!(text.matches("BREP_WITH_VOIDS").count(), 0);
|
||
let imp = crate::step_import(&text).unwrap();
|
||
let v: f64 = imp.bodies.iter().map(|b| crate::measure(&b.body).unwrap().volume).sum();
|
||
assert!((v - (800.0 + 36.0) * 2.0).abs() < 1e-6, "{v}");
|
||
// A real void stays a void.
|
||
let hollow = crate::boolean(
|
||
&crate::box_solid(Vec3::ZERO, Vec3::new(10.0, 10.0, 10.0)).unwrap(),
|
||
&crate::box_solid(Vec3::new(3.0, 3.0, 3.0), Vec3::new(7.0, 7.0, 7.0)).unwrap(),
|
||
crate::BoolOp::Cut,
|
||
)
|
||
.unwrap()
|
||
.unwrap();
|
||
assert_eq!(hollow.shell_count(), 2);
|
||
let text = crate::step_export(&[&hollow], "test").unwrap();
|
||
assert_eq!(text.matches("BREP_WITH_VOIDS").count(), 1, "{text}");
|
||
}
|
||
|
||
/// #3394: a plate on four tapered legs and a straight peg. Each leg's cone and the peg's
|
||
/// cylinder are written as one face whose loop runs ring, seam, ring, seam. Readers put the
|
||
/// seam's first use on the side where the surface's angle starts and lay the next ring out
|
||
/// from there, so that ring must turn the way the angle grows (anticlockwise about the
|
||
/// written axis); three of the legs came out the other way and other readers dropped their
|
||
/// sides.
|
||
#[test]
|
||
fn seam_loops_turn_the_way_the_angle_grows() {
|
||
use solidcraft_geom::{Loop2, Plane, Region2, Vec2};
|
||
let plate = crate::box_solid(Vec3::new(-60.0, -40.0, 0.0), Vec3::new(60.0, 40.0, 10.0)).unwrap();
|
||
let mut b = plate;
|
||
for (x, y) in [(-45.0, -30.0), (45.0, -30.0), (45.0, 30.0), (-45.0, 30.0)] {
|
||
let disc = Region2 { outer: Loop2::circle(Vec2::new(x, y), 5.0), holes: vec![] };
|
||
let leg = crate::extrude_tapered(&Plane::XY, &disc, 20.0, -1.0, 2f64.to_radians()).unwrap();
|
||
b = crate::boolean(&b, &leg, crate::BoolOp::Union).unwrap().unwrap();
|
||
}
|
||
let peg = crate::cylinder(Vec3::new(0.0, 0.0, 10.0), Vec3::Z, 4.0, 8.0).unwrap();
|
||
b = crate::boolean(&b, &peg, crate::BoolOp::Union).unwrap().unwrap();
|
||
let text = crate::step_export(&[&b], "test").unwrap();
|
||
let ex = p21::parse(&text).unwrap();
|
||
let mut seamed = 0;
|
||
for face in ex.entities.values().filter(|e| e.name() == "ADVANCED_FACE") {
|
||
let surface = ex.get(face.params().get(2).unwrap().as_ref_id().unwrap()).unwrap();
|
||
if !matches!(surface.name(), "CONICAL_SURFACE" | "CYLINDRICAL_SURFACE") {
|
||
continue;
|
||
}
|
||
let frame = ex.get(surface.params().get(1).unwrap().as_ref_id().unwrap()).unwrap();
|
||
let o = triple(&ex, frame.params().get(1).unwrap().as_ref_id().unwrap());
|
||
let z = triple(&ex, frame.params().get(2).unwrap().as_ref_id().unwrap());
|
||
for lp in face_edges(&ex, face).unwrap() {
|
||
let Some(i) = lp.iter().position(|(e, _)| lp.iter().filter(|(f, _)| f == e).count() == 2) else { continue };
|
||
let &(edge, dir) = lp.get((i + 1) % lp.len()).unwrap();
|
||
let p = ex.get(edge).unwrap().params();
|
||
let (v0, v1) = (p.get(1).unwrap().as_ref_id().unwrap(), p.get(2).unwrap().as_ref_id().unwrap());
|
||
let mut pts = edge_points(&ex, edge, 4).unwrap();
|
||
if p.get(4).unwrap().as_bool().unwrap() != dir {
|
||
pts.reverse();
|
||
}
|
||
let start = vertex_point(&ex, if dir { v0 } else { v1 }).unwrap();
|
||
let radial = |q: V3| {
|
||
let v = sub(q, o);
|
||
sub(v, mul(z, dot(v, z)))
|
||
};
|
||
let turn = dot(cross(radial(start), radial(pts[1])), z);
|
||
assert!(turn > 0.0, "face #{:?}: the ring after the seam turns against the angle", face.params().first());
|
||
seamed += 1;
|
||
}
|
||
}
|
||
assert_eq!(seamed, 5, "{text}");
|
||
}
|
||
|
||
/// A CARTESIAN_POINT's or DIRECTION's three numbers.
|
||
fn triple(ex: &p21::Exchange, id: u64) -> V3 {
|
||
let c = ex.get(id).unwrap().params().get(1).unwrap().as_list().unwrap();
|
||
[c[0].as_f64().unwrap(), c[1].as_f64().unwrap(), c[2].as_f64().unwrap()]
|
||
}
|
||
|
||
#[test]
|
||
fn numbers_and_strings() {
|
||
assert_eq!(real(1.0), "1.0");
|
||
assert_eq!(real(1e-6), "1.E-6");
|
||
assert_eq!(real(-2.5e20), "-2.5E20");
|
||
assert_eq!(real(3.0e100), "3.E100");
|
||
assert_eq!(string("it's"), "'it''s'");
|
||
assert_eq!(string("é"), "'\\X2\\00E9\\X0\\'");
|
||
let ex = p21::parse(&format!("ISO-10303-21;DATA;#1=A({},{});ENDSEC;END-ISO-10303-21;", string("a'b\\é"), real(1e-6))).unwrap();
|
||
let p = ex.get(1).unwrap().params();
|
||
assert_eq!(p[0].as_str(), Some("a'b\\é"));
|
||
assert_eq!(p[1].as_f64(), Some(1e-6));
|
||
// Names of several non-ASCII characters in a row read back whole (#2344).
|
||
for name in ["圆角", "凸台-拉伸7", "ネジ穴", "Gehäuse 😀"] {
|
||
let ex = p21::parse(&format!("ISO-10303-21;DATA;#1=A({});ENDSEC;END-ISO-10303-21;", string(name))).unwrap();
|
||
assert_eq!(ex.get(1).unwrap().params()[0].as_str(), Some(name));
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn assembly_names_colours_round_trip() {
|
||
use crate::{box_solid, cylinder, measure, step_import, step_validate};
|
||
let bx = box_solid(solidcraft_geom::Vec3::ZERO, solidcraft_geom::Vec3::new(10.0, 20.0, 5.0)).unwrap();
|
||
let pin = cylinder(solidcraft_geom::Vec3::ZERO, solidcraft_geom::Vec3::Z, 2.0, 8.0).unwrap();
|
||
let rot90 = [[0.0, 1.0, 0.0, 0.0], [-1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [50.0, 0.0, 0.0, 1.0]];
|
||
let shift = [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 5.0, 1.0]];
|
||
let products = vec![
|
||
ExportProduct {
|
||
name: "Root Ä".into(),
|
||
bodies: vec![ExportBody { name: "Base".into(), body: &bx, color: Some([1.0, 0.0, 0.0]) }],
|
||
children: vec![(1, shift, "Pin:1".into()), (1, rot90, "Pin:2".into())],
|
||
},
|
||
ExportProduct { name: "Pin".into(), bodies: vec![ExportBody { name: "Shaft".into(), body: &pin, color: None }], children: vec![] },
|
||
];
|
||
let text = step_export_products(&products, 0, &StepHeader { file_name: "a.step".into(), ..Default::default() }).unwrap();
|
||
step_validate(&text).unwrap();
|
||
assert!(text.contains("AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF"));
|
||
assert_eq!(text.matches("NEXT_ASSEMBLY_USAGE_OCCURRENCE").count(), 2);
|
||
// Shared geometry: the unit Z direction is written once.
|
||
assert_eq!(text.matches("DIRECTION('',(0.0,0.0,1.0))").count(), 1);
|
||
let imp = step_import(&text).unwrap();
|
||
assert!(imp.warnings.is_empty(), "{:?}", imp.warnings);
|
||
assert_eq!(imp.bodies.len(), 3);
|
||
let names: Vec<&str> = imp.bodies.iter().map(|b| b.name.as_str()).collect();
|
||
assert_eq!(names, ["Base", "Shaft", "Shaft"]);
|
||
assert_eq!(imp.bodies[0].color, Some([1.0, 0.0, 0.0]));
|
||
assert_eq!(imp.tree[0].name, "Root Ä");
|
||
assert_eq!(imp.tree[0].children.len(), 2);
|
||
let m: Vec<_> = imp.bodies.iter().map(|b| measure(&b.body).unwrap()).collect();
|
||
assert!((m[1].bbox.min.z - 5.0).abs() < 1e-6 && (m[1].bbox.max.z - 13.0).abs() < 1e-6);
|
||
// Rotated 90° about Z and moved 50 along X: centre at (50, 0).
|
||
assert!(m[2].centroid.dist(solidcraft_geom::Vec3::new(50.0, 0.0, 4.0)) < 1e-3, "{:?}", m[2].centroid);
|
||
// Recursion and bad placements are errors.
|
||
let cyc = vec![ExportProduct {
|
||
name: "A".into(),
|
||
bodies: vec![ExportBody { name: "B".into(), body: &bx, color: None }],
|
||
children: vec![(0, shift, String::new())],
|
||
}];
|
||
assert!(step_export_products(&cyc, 0, &StepHeader::default()).is_err());
|
||
let scaled = [[2.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0; 4]];
|
||
let bad = vec![
|
||
ExportProduct { name: "A".into(), bodies: vec![], children: vec![(1, scaled, String::new())] },
|
||
ExportProduct { name: "B".into(), bodies: vec![ExportBody { name: "B".into(), body: &bx, color: None }], children: vec![] },
|
||
];
|
||
assert!(step_export_products(&bad, 0, &StepHeader::default()).is_err());
|
||
}
|
||
}
|