Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

STEP import: orient each instanced part once (#2814) (#2875)

bherbruck5997d28de73e
diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rs
index 642826affc..feea4c25a9 100644
--- a/crates/kernel/src/body.rs
+++ b/crates/kernel/src/body.rs
@@ -492,6 +492,12 @@ fn polyline_mid(pts: &[Vec3]) -> (Vec3, f64) {
(pts.first().copied().unwrap_or_default(), len)
}
+#[cfg(test)]
+thread_local! {
+ /// Solids [`Body::new`] meshed on this thread to orient them (tests count the work an import does).
+ pub(crate) static ORIENTED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
/// Deflection the orientation mesh uses: coarse enough for a large solid, fine enough that a
/// small one still tessellates. `unmeshed_faces` counts at the same value, so the count the
/// orientation mesh produced is reused instead of meshing the body again.
@@ -559,13 +565,17 @@ impl Body {
Ok((volume, missing))
})
};
- let (mut v, mut missing) = orient(tol)?;
+ #[cfg(test)]
+ ORIENTED.with(|n| n.set(n.get() + 1));
+ // The faces missing from the coarse mesh are the same whichever way the solid turns out
+ // to face, so the count is kept for `unmeshed_faces` either way.
+ let (mut v, missing) = orient(tol)?;
// A long thin round part (a through hole's tool: a cylinder whose vertices all lie on
// its seam, so they span its length only) meshed that coarsely can come out with a
// negative volume when it is outward already: check finely before turning it inside out.
let fine = (tol * 0.02).max(1e-4);
if v < 0.0 && fine < tol {
- (v, missing) = orient(fine)?;
+ (v, _) = orient(fine)?;
}
if v < 0.0 {
solid.not();
@@ -574,7 +584,7 @@ impl Body {
solid: std::sync::Arc::new(solid),
size: if span.is_finite() && span > 0.0 { span } else { 0.0 },
volume: Some(std::sync::Arc::new(std::sync::Mutex::new(None))),
- coarse_missing: (v >= 0.0).then_some((tol, missing)),
+ coarse_missing: Some((tol, missing)),
mesh: None,
color: None,
paint: None,
@@ -595,7 +605,15 @@ impl Body {
if solid.boundaries().is_empty() {
return Err(KernelError::Failed("empty result".into()));
}
- let mut solid = rephase_revolved(solid);
+ Body::placed_as_is(rephase_revolved(solid), flip, coarse)
+ }
+
+ /// [`Body::new_placed`] for a solid whose revolved faces were already turned away from
+ /// their seam (a placement of an oriented body keeps them where they were).
+ fn placed_as_is(mut solid: Solid, flip: bool, coarse: Option<(f64, usize)>) -> Result<Body> {
+ if solid.boundaries().is_empty() {
+ return Err(KernelError::Failed("empty result".into()));
+ }
let span = span_of(&solid);
if flip {
solid.not();
@@ -616,6 +634,23 @@ impl Body {
})
}
+ /// This oriented body's solid moved by `m` (an affine placement), as [`Body::new_placed`]
+ /// makes it: the orientation comes from the matrix, so a part placed many times (assembly
+ /// instances) is meshed to orient it only once. Topology only; appearance is the caller's.
+ pub(crate) fn placed(&self, m: &mt::Matrix4) -> Result<Body> {
+ use mt::SquareMatrix as _;
+ if *m == mt::Matrix4::from_scale(1.0) {
+ return Ok(self.clone());
+ }
+ let a = [[m.x.x, m.x.y, m.x.z, m.x.w], [m.y.x, m.y.y, m.y.z, m.y.w], [m.z.x, m.z.y, m.z.z, m.z.w], [m.w.x, m.w.y, m.w.z, m.w.w]];
+ let det = m.determinant();
+ if !det.is_finite() || det.abs() < 1e-12 {
+ return Err(KernelError::Invalid("degenerate placement".into()));
+ }
+ let rigid = crate::ops::rigid_placement(&a);
+ Body::placed_as_is(mt::builder::transformed(&*self.solid, *m), det < 0.0, rigid.then_some(self.coarse_missing).flatten())
+ }
+
pub(crate) fn inherit_regularization_protection(mut self, input: &Body) -> Self {
self.regularization_protected |= input.regularization_protected;
self
@@ -1254,7 +1289,7 @@ impl Body {
if self.is_mesh() {
return 0;
}
- let tol = (self.size() * 1e-2).max(1e-3);
+ let tol = orientation_tolerance(self.size());
if let Some((cached_tol, missing)) = self.coarse_missing
&& cached_tol == tol
{
diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rs
index 8433beb150..4194412c1b 100644
--- a/crates/kernel/src/ops.rs
+++ b/crates/kernel/src/ops.rs
@@ -1686,7 +1686,7 @@ fn det3(m: &[[f64; 4]; 4]) -> f64 {
}
/// Whether the linear part is a rigid motion (rotation or reflection: no scale or shear).
-fn rigid_placement(m: &[[f64; 4]; 4]) -> bool {
+pub(crate) fn rigid_placement(m: &[[f64; 4]; 4]) -> bool {
let r = [Vec3::new(m[0][0], m[0][1], m[0][2]), Vec3::new(m[1][0], m[1][1], m[1][2]), Vec3::new(m[2][0], m[2][1], m[2][2])];
(0..3).all(|i| (r[i].dot(r[i]) - 1.0).abs() < 1e-9) && r[0].dot(r[1]).abs() < 1e-9 && r[0].dot(r[2]).abs() < 1e-9 && r[1].dot(r[2]).abs() < 1e-9
}
diff --git a/crates/kernel/src/step_in/mod.rs b/crates/kernel/src/step_in/mod.rs
index b3f49f3031..f40e447701 100644
--- a/crates/kernel/src/step_in/mod.rs
+++ b/crates/kernel/src/step_in/mod.rs
@@ -270,6 +270,9 @@ struct Reader {
/// An item placed more than once: its first instance's display, shared by the later ones
/// (with the placement that first instance had), so the part is meshed once.
shown: HashMap<u64, (Arc<crate::body::SharedDisplay>, mt::Matrix4)>,
+ /// An item placed more than once: its body oriented where the file defines it, so each
+ /// later instance is only placed (orienting meshes the whole part).
+ oriented: HashMap<u64, Body>,
used_items: HashSet<u64>,
/// Items already instanced for the product being read.
node_items: HashSet<u64>,
@@ -312,6 +315,7 @@ impl Reader {
solids: HashMap::new(),
once: HashSet::new(),
shown: HashMap::new(),
+ oriented: HashMap::new(),
used_items: HashSet::new(),
node_items: HashSet::new(),
visits: 0,
@@ -743,7 +747,11 @@ impl Reader {
Err(shared) => (*shared).clone(),
};
sources.push((i, item, closed, file_faces, face_origin));
- solids.push(parallel::Job { solid, check_mesh: !self.unmeshed_checked.contains(&item) });
+ let source = match self.oriented.get(&item) {
+ Some(body) => parallel::Source::Oriented(body.clone()),
+ None => parallel::Source::Solid(solid),
+ };
+ solids.push(parallel::Job { source, check_mesh: !self.unmeshed_checked.contains(&item) });
}
let Some(batch) = self.batches.get(id) else { return true };
let (m, path, product, instance) = (batch.m, batch.path.clone(), batch.product.clone(), batch.instance.clone());
@@ -751,7 +759,10 @@ impl Reader {
for ((i, item, closed, file_faces, face_origin), body) in sources.into_iter().zip(prepared) {
let Some(e) = ex.get(item) else { continue };
match body {
- Ok((body, missing)) => {
+ Ok((body, missing, oriented)) => {
+ if !self.once.contains(&item) {
+ self.oriented.entry(item).or_insert(oriented);
+ }
let own = e.params().first().and_then(Param::as_str).unwrap_or("").trim().to_string();
let name = if own.is_empty() { product.clone() } else { own };
// Faces the mesher gives up on (or that the budget cut short) are reported.
diff --git a/crates/kernel/src/step_in/parallel.rs b/crates/kernel/src/step_in/parallel.rs
index 4883a1d7bd..2d9854eb6b 100644
--- a/crates/kernel/src/step_in/parallel.rs
+++ b/crates/kernel/src/step_in/parallel.rs
@@ -2,11 +2,20 @@
use super::{Body, Result, guard, mt};
pub(super) struct Job {
- pub solid: mt::Solid,
+ pub source: Source,
pub check_mesh: bool,
}
-type Prepared = Result<(Body, usize)>;
+/// What a job places: a solid read from the file (oriented here), or a body an earlier
+/// instance of the same item already oriented.
+pub(super) enum Source {
+ Solid(mt::Solid),
+ Oriented(Body),
+}
+
+/// The placed body, its faces the mesher missed, and the body oriented where the file defines
+/// it (for later instances of the same item).
+type Prepared = Result<(Body, usize, Body)>;
pub(super) fn workers() -> usize {
#[cfg(not(target_arch = "wasm32"))]
@@ -21,10 +30,17 @@ pub(super) fn workers() -> usize {
fn prepare(job: &Job, placement: &mt::Matrix4) -> Prepared {
guard("STEP body preparation", || {
- let solid = if *placement == mt::Matrix4::from_scale(1.0) { job.solid.clone() } else { mt::builder::transformed(&job.solid, *placement) };
- let body = Body::new(solid)?;
- let missing = if job.check_mesh { body.unmeshed_faces() } else { 0 };
- Ok((body, missing))
+ // Orient once where the file defines the solid; each placement then takes its
+ // orientation from the matrix instead of meshing the whole part again.
+ let oriented = match &job.source {
+ Source::Solid(solid) => Body::new(solid.clone())?,
+ Source::Oriented(body) => body.clone(),
+ };
+ let body = oriented.placed(placement)?;
+ // Counted where the orientation mesh already counted them (a placement meshes the
+ // same faces).
+ let missing = if job.check_mesh { oriented.unmeshed_faces() } else { 0 };
+ Ok((body, missing, oriented))
})
}
diff --git a/crates/kernel/src/step_in/tests.rs b/crates/kernel/src/step_in/tests.rs
index 30c52de257..2f77919155 100644
--- a/crates/kernel/src/step_in/tests.rs
+++ b/crates/kernel/src/step_in/tests.rs
@@ -242,7 +242,7 @@ fn parallel_body_preparation_reports_errors_in_place_and_preserves_placement() {
let body = cylinder(Vec3::new(2.0, 2.0, 0.0), Vec3::Z, 2.0, 4.0).unwrap();
let solids = vec![body.solid.as_ref().clone(), mt::Solid::new(Vec::new()), body.solid.as_ref().clone(), body.solid.as_ref().clone()];
let placement = mt::Matrix4::from_translation(mt::Vector3::new(10.0, 20.0, 30.0));
- let jobs: Vec<_> = solids.into_iter().map(|solid| parallel::Job { solid, check_mesh: true }).collect();
+ let jobs: Vec<_> = solids.into_iter().map(|solid| parallel::Job { source: parallel::Source::Solid(solid), check_mesh: true }).collect();
let serial = parallel::bodies(&jobs, &placement, 1);
let threaded = parallel::bodies(&jobs, &placement, 4);
assert_eq!(serial.len(), 4);
@@ -653,6 +653,63 @@ fn hand_written_assembly() {
assert!((root.children[1].transform[3][0] - 100.0).abs() < 1e-9);
}
+/// The cube part (in cm) placed `n` times in a millimetre assembly, each instance moved along X
+/// and turned about Z.
+fn instanced_assembly(n: u64) -> String {
+ let mut t = String::from(HEAD);
+ t += "#8=PRODUCT_DEFINITION_CONTEXT('part definition',#9,'design');\n#9=APPLICATION_CONTEXT('');\n";
+ t += &cube_entities();
+ t += &context(20, "(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.CENTI.,.METRE.))");
+ t += &context(30, "(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.))");
+ t += &product(50, "Block");
+ t += &product(70, "Assembly");
+ t += "#60=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#101,#65),#20);\n#61=SHAPE_DEFINITION_REPRESENTATION(#54,#60);\n";
+ t += "#65=AXIS2_PLACEMENT_3D('',#66,$,$);\n#66=CARTESIAN_POINT('',(0.,0.,0.));\n";
+ let items: Vec<String> = (0..n).map(|k| format!("#{}", 3000 + k * 10)).collect();
+ t += &format!("#80=SHAPE_REPRESENTATION('',({}),#30);\n#88=SHAPE_DEFINITION_REPRESENTATION(#74,#80);\n", items.join(","));
+ for k in 0..n {
+ let (a, turn) = (3000 + k * 10, k as f64 * 0.7);
+ t += &format!("#{a}=AXIS2_PLACEMENT_3D('',#{},#{},#{});\n", a + 1, a + 2, a + 3);
+ t += &format!("#{}=CARTESIAN_POINT('',({}.,0.,0.));\n", a + 1, 50 * k);
+ t += &format!("#{}=DIRECTION('',(0.,0.,1.));\n#{}=DIRECTION('',({},{},0.));\n", a + 2, a + 3, turn.cos(), turn.sin());
+ let u = 6000 + k * 10;
+ t += &format!("#{u}=NEXT_ASSEMBLY_USAGE_OCCURRENCE('{k}','Block:{k}','',#70,#50,$);\n");
+ t += &format!("#{}=PRODUCT_DEFINITION_SHAPE('','',#{u});\n", u + 1);
+ t += &format!("#{}=ITEM_DEFINED_TRANSFORMATION('','',#65,#{a});\n", u + 2);
+ t += &format!(
+ "#{}=(REPRESENTATION_RELATIONSHIP('','',#60,#80)REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#{})SHAPE_REPRESENTATION_RELATIONSHIP());\n",
+ u + 3,
+ u + 2
+ );
+ t += &format!("#{}=CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#{},#{});\n", u + 4, u + 3, u + 1);
+ }
+ t += TAIL;
+ t
+}
+
+/// A part placed many times is oriented (meshed whole) once, not once per instance (#2814:
+/// an assembly with hundreds of instances spent most of an hour re-meshing the same parts),
+/// and every instance still comes out outward-facing at its own place.
+#[test]
+fn instanced_parts_are_oriented_once() {
+ let n = 24;
+ let t = instanced_assembly(n);
+ crate::body::ORIENTED.with(|c| c.set(0));
+ let imp = step_import_with_workers(&t, 1).unwrap();
+ assert_eq!(crate::body::ORIENTED.with(|c| c.get()), 1, "one distinct part");
+ assert_eq!(imp.bodies.len(), n as usize);
+ assert!(imp.warnings.is_empty(), "{:?}", imp.warnings);
+ for (k, b) in imp.bodies.iter().enumerate() {
+ let m = measure(&b.body).unwrap();
+ assert!(rel(m.volume, 1000.0) < 1e-9, "instance {k}: {}", m.volume);
+ let centre = (m.bbox.min + m.bbox.max) * 0.5;
+ let turn = k as f64 * 0.7;
+ let expected = Vec3::new(50.0 * k as f64 + 5.0 * (turn.cos() - turn.sin()), 5.0 * (turn.sin() + turn.cos()), 5.0);
+ assert!(centre.dist(expected) < 1e-6, "instance {k}: {centre:?} vs {expected:?}");
+ }
+ assert_same_import(&imp, &step_import_with_workers(&t, 8).unwrap());
+}
+
/// A part an assembly places twice is meshed once: the second instance shows the first one's
/// display mesh, placed (the same triangles and faces, at its own place), and keeps its own
/// placed geometry for everything else.