diff --git a/crates/kernel/src/body.rs b/crates/kernel/src/body.rs index 642826aff..feea4c25a 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 = 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 { + 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 { + 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 8433beb15..4194412c1 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 b3f49f303..f40e44770 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, 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, used_items: HashSet, /// Items already instanced for the product being read. node_items: HashSet, @@ -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 4883a1d7b..2d9854eb6 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 30c52de25..2f7791915 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 = (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.