Wave 292/509: STEP import: a refused solid comes in as a surface body of its exact faces (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. -fd5319a0ejyviko: docs: the kernel's move from truck to SMLib, as written up on #4012 -4cb0d6ee9jyviko: STEP import: a refused solid comes in as a surface body of its exact faces -e19785620jyviko: STEP import: a refused solid's surface body faces as the file has it -529fb7cf3jyviko: Release: macOS builds on macos-15 (GitHub retires macos-14 on 2026-11-02) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
1 parent
53f4d607e2
commit
65b02ff7ab
6 files changed
+476
-96
No files matched your search
@@ -26,8 +26,9 @@ pub(super) struct Part {
|
||||
pub file_faces: usize,
|
||||
/// The file face of each kernel face.
|
||||
pub face_origin: Vec<u64>,
|
||||
/// No B-rep could be made of the solid: the body is a mesh of the faces that could be read
|
||||
/// on their own ([`mesh_part`]), and this is why the solid was refused.
|
||||
/// No B-rep could be made of the whole solid, and this is why: the body is a surface body of
|
||||
/// the faces that read ([`surface_part`]), or, where none could be made of them, a mesh of
|
||||
/// them ([`mesh_part`]).
|
||||
pub refused: Option<String>,
|
||||
}
|
||||
|
||||
@@ -66,7 +67,7 @@ fn prepare(ex: &Exchange, job: &Job) -> Prepared {
|
||||
let (part, read) = match &job.source {
|
||||
Source::Oriented(part) => (part.clone(), None),
|
||||
Source::Item { item, units } => {
|
||||
let (part, read) = smlib_part(ex, *item, *units).or_else(|refused| mesh_part(ex, *item, *units, refused))?;
|
||||
let (part, read) = smlib_part(ex, *item, *units).or_else(|refused| surface_part(ex, *item, *units, refused))?;
|
||||
(Arc::new(part), Some(read))
|
||||
}
|
||||
};
|
||||
@@ -88,67 +89,221 @@ fn placed(body: &Body, m: &M4) -> crate::Result<Body> {
|
||||
|
||||
/// A solid item read with the STEP reader into its schema 4 record, then into SMLib as given,
|
||||
/// and brought back as a body: the part SMLib made of the file. A solid the reader or SMLib
|
||||
/// refuses fails with the reason ([`mesh_part`] then shows what it can of it).
|
||||
/// refuses fails with the reason ([`surface_part`] then imports what it can of it).
|
||||
pub(super) fn smlib_part(ex: &Exchange, item: u64, units: Units) -> std::result::Result<(Part, Vec<String>), Failure> {
|
||||
let solid = solidcraft_profile::scope("import", "step.read_solid", || {
|
||||
solidcraft_step::topology::read_solid_with(ex, item, units, &solidcraft_smlib::pcurves::SmlibTrims)
|
||||
})
|
||||
.map_err(|msg| Failure { read: true, msg })?;
|
||||
let failed = |e: KernelError| Failure { read: false, msg: e.to_string().trim_start_matches("the operation failed: ").to_string() };
|
||||
let (brep, smlib_order) = crate::native::smlib_record_ordered(&solid.brep).map_err(failed)?;
|
||||
let (body, body_order) = crate::native::body_from_smlib_ordered(&brep).map_err(failed)?;
|
||||
// The file face of each body face: SMLib's face i is the record's `smlib_order` face and the
|
||||
// body's `body_order` face (an empty order is the same one).
|
||||
let (Some(smlib_order), Some(body_order)) = (smlib_order, body_order) else {
|
||||
return Err(Failure { read: false, msg: "not supported yet: SMLib renumbered the solid's faces".into() });
|
||||
};
|
||||
let at = |order: &[usize], i: usize| if order.is_empty() { Some(i) } else { order.get(i).copied() };
|
||||
let faces = brep.counts().map_err(|e| failed(KernelError::Failed(format!("SMLib: {e}"))))?[0];
|
||||
let mut face_origin = vec![0u64; body.face_count()];
|
||||
for i in 0..faces {
|
||||
let file_face = at(&smlib_order.faces, i).and_then(|r| solid.face_origin.get(r)).copied();
|
||||
match (at(&body_order.faces, i).and_then(|b| face_origin.get_mut(b)), file_face) {
|
||||
(Some(slot), Some(f)) => *slot = f,
|
||||
_ => return Err(Failure { read: false, msg: "not supported yet: SMLib renumbered the solid's faces".into() }),
|
||||
}
|
||||
}
|
||||
let part = Part { body, closed: !solid.sheet, file_faces: solid.face_origin.len(), face_origin, refused: None };
|
||||
let part = solid_part(&solid)?;
|
||||
Ok((part, solid.notes))
|
||||
}
|
||||
|
||||
/// A solid the reader or SMLib refuses, still shown: each of its faces read on its own
|
||||
/// ([`solidcraft_step::topology::read_faces_with`]) and meshed by the planner as a one-face
|
||||
/// surface body, the faces' triangles together a mesh body. It is no B-rep (modelling
|
||||
/// operations refuse it); `refused` says why. Faces that cannot be read or meshed on their own
|
||||
/// are left out, each named in the notes. With no face to show, the solid stays refused.
|
||||
fn mesh_part(ex: &Exchange, item: u64, units: Units, refused: Failure) -> std::result::Result<(Part, Vec<String>), Failure> {
|
||||
let _span = solidcraft_profile::span("import", "step.refused_mesh");
|
||||
let faces = match solidcraft_step::topology::read_faces_with(ex, item, units, &solidcraft_smlib::pcurves::SmlibTrims) {
|
||||
Ok(faces) => faces,
|
||||
Err(_) => return Err(refused),
|
||||
};
|
||||
let mut notes = Vec::new();
|
||||
let mut bodies = Vec::with_capacity(faces.len());
|
||||
for f in &faces {
|
||||
match f.record.clone().map_err(KernelError::Failed).and_then(Body::from_record) {
|
||||
Ok(b) => bodies.push((f.face, b)),
|
||||
Err(e) => notes.push(format!("not shown: {}", e.to_string().trim_start_matches("the operation failed: "))),
|
||||
/// The part SMLib makes of a solid (or sheet) record the reader made.
|
||||
///
|
||||
/// SMLib holds both sides of a sheet's faces and gives each back facing its surface's natural
|
||||
/// normal, so a sheet whose file uses some faces the other way is given to SMLib with those faces
|
||||
/// turned over (exactly, on the record) and they are turned back on SMLib's body: the body faces
|
||||
/// as the file does, and each of its faces is known to be the record's face it was.
|
||||
fn solid_part(solid: &solidcraft_step::topology::Solid) -> std::result::Result<Part, Failure> {
|
||||
let failed = |e: KernelError| Failure { read: false, msg: e.to_string().trim_start_matches("the operation failed: ").to_string() };
|
||||
let r = &solid.brep;
|
||||
let mut reversed = vec![false; r.faces.len()];
|
||||
if solid.sheet {
|
||||
for s in &r.shells {
|
||||
if let solidcraft_geom::brep::Shell::Faces { faces, .. } = s {
|
||||
for f in faces.iter().filter(|f| !f.forward) {
|
||||
if let Some(slot) = reversed.get_mut(f.face as usize) {
|
||||
*slot = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let (body, of_record) = if reversed.iter().any(|r| *r) {
|
||||
let turn = |body: &Body, by: &dyn Fn(usize) -> bool| -> crate::Result<(Body, Vec<usize>)> {
|
||||
let picked: Vec<(usize, bool)> = (0..body.face_count()).map(|f| (f, by(f))).collect();
|
||||
let turned = crate::surfaces::taken(body, body.record(), &picked)?;
|
||||
let from = kept_faces(&turned).ok_or_else(|| KernelError::Failed("a face turned over from no one face".into()))?;
|
||||
Ok((turned, from))
|
||||
};
|
||||
let as_read = Body::from_record(r.clone()).map_err(failed)?;
|
||||
// `natural`'s face j is the record's `to_record[j]`; SMLib's body's face k is `natural`'s
|
||||
// `of_natural[k]`; the body turned back's face i is SMLib's `back[i]`.
|
||||
let (natural, to_record) = turn(&as_read, &|f| reversed.get(f).copied().unwrap_or(false)).map_err(failed)?;
|
||||
let (smlib, of_natural) = smlib_body(natural.record())?;
|
||||
let record_of = |k: usize| of_natural.get(k).and_then(|j| to_record.get(*j)).copied();
|
||||
let (back, from) = turn(&smlib, &|k| record_of(k).and_then(|f| reversed.get(f)).copied().unwrap_or(false)).map_err(failed)?;
|
||||
let of_record = from.iter().map(|k| record_of(*k)).collect::<Option<Vec<usize>>>().ok_or_else(renumbered)?;
|
||||
(back.without_history(), of_record)
|
||||
} else {
|
||||
smlib_body(r)?
|
||||
};
|
||||
let face_origin = of_record.iter().map(|f| solid.face_origin.get(*f).copied()).collect::<Option<Vec<u64>>>().ok_or_else(renumbered)?;
|
||||
Ok(Part { body, closed: !solid.sheet, file_faces: solid.face_origin.len(), face_origin, refused: None })
|
||||
}
|
||||
|
||||
fn renumbered() -> Failure {
|
||||
Failure { read: false, msg: "not supported yet: SMLib renumbered the solid's faces".into() }
|
||||
}
|
||||
|
||||
/// The body SMLib makes of `record` as given, and the record's face each of its faces is.
|
||||
fn smlib_body(record: &solidcraft_geom::brep::Brep) -> std::result::Result<(Body, Vec<usize>), Failure> {
|
||||
let failed = |e: KernelError| Failure { read: false, msg: e.to_string().trim_start_matches("the operation failed: ").to_string() };
|
||||
let (brep, smlib_order) = crate::native::smlib_record_ordered(record).map_err(failed)?;
|
||||
let (body, body_order) = crate::native::body_from_smlib_ordered(&brep).map_err(failed)?;
|
||||
// SMLib's face i is the record's `smlib_order` face and the body's `body_order` face (an
|
||||
// empty order is the same one).
|
||||
let (Some(smlib_order), Some(body_order)) = (smlib_order, body_order) else { return Err(renumbered()) };
|
||||
let at = |order: &[usize], i: usize| if order.is_empty() { Some(i) } else { order.get(i).copied() };
|
||||
let faces = brep.counts().map_err(|e| failed(KernelError::Failed(format!("SMLib: {e}"))))?[0];
|
||||
let mut of_record = vec![usize::MAX; body.face_count()];
|
||||
for i in 0..faces {
|
||||
match (at(&body_order.faces, i).and_then(|b| of_record.get_mut(b)), at(&smlib_order.faces, i).filter(|r| *r < record.faces.len())) {
|
||||
(Some(slot), Some(r)) => *slot = r,
|
||||
_ => return Err(renumbered()),
|
||||
}
|
||||
}
|
||||
if of_record.contains(&usize::MAX) {
|
||||
return Err(renumbered());
|
||||
}
|
||||
Ok((body, of_record))
|
||||
}
|
||||
|
||||
/// The face of its one operand each face of `body` is, from its history.
|
||||
fn kept_faces(body: &Body) -> Option<Vec<usize>> {
|
||||
let h = body.history()?;
|
||||
let from: Vec<usize> = h
|
||||
.faces
|
||||
.iter()
|
||||
.map(|f| match f.origins.as_slice() {
|
||||
[crate::history::FaceOrigin::Face { operand: 0, face }] => Some(*face),
|
||||
_ => None,
|
||||
})
|
||||
.collect::<Option<_>>()?;
|
||||
(from.len() == body.face_count()).then_some(from)
|
||||
}
|
||||
|
||||
/// Most reads of a refused solid without faces, each leaving out the face the refusal before names.
|
||||
const MAX_LEFT_OUT_ROUNDS: usize = 8;
|
||||
|
||||
/// A solid the reader or SMLib refuses, imported as an open surface body of its exact faces, the
|
||||
/// faces that make it refused left out and named in the notes; `refused` says why the solid was.
|
||||
/// Each face is read on its own first ([`solidcraft_step::topology::read_faces_with`]); then:
|
||||
/// 1. the solid is read again without the faces that cannot be read alone and the face the
|
||||
/// refusal names, as one sheet whose faces share their edges as the file has them, and made
|
||||
/// by SMLib; a refusal of that naming another face of the solid leaves it out too (up to
|
||||
/// [`MAX_LEFT_OUT_ROUNDS`] reads). A face is only ever left out where a refusal names it.
|
||||
/// 2. Where a refusal names no face of the solid: the faces that read alone, stitched by SMLib
|
||||
/// into one surface body (their edges sewn at ten times their tolerance).
|
||||
/// 3. Where SMLib cannot stitch them either: a mesh of them ([`mesh_part`]).
|
||||
///
|
||||
/// With no face to import, the solid stays refused.
|
||||
fn surface_part(ex: &Exchange, item: u64, units: Units, refused: Failure) -> std::result::Result<(Part, Vec<String>), Failure> {
|
||||
let _span = solidcraft_profile::span("import", "step.refused_surfaces");
|
||||
let trims = &solidcraft_smlib::pcurves::SmlibTrims;
|
||||
let Ok(faces) = solidcraft_step::topology::read_faces_with(ex, item, units, trims) else { return Err(refused) };
|
||||
let of_solid: std::collections::HashSet<u64> = faces.iter().map(|f| f.face).collect();
|
||||
// The faces left out, each with the refusal that names it, in the order they were found.
|
||||
let mut left_out: Vec<(u64, String)> = faces.iter().filter_map(|f| f.record.as_ref().err().map(|m| (f.face, m.clone()))).collect();
|
||||
let mut why = refused.msg.clone();
|
||||
let mut rounds = 0;
|
||||
loop {
|
||||
// The face the last refusal names, if it is one of the solid's still in, is left out too.
|
||||
let named = solidcraft_step::topology::named_face(&why).filter(|f| of_solid.contains(f) && !left_out.iter().any(|(g, _)| g == f));
|
||||
match named {
|
||||
Some(f) => left_out.push((f, why.clone())),
|
||||
None if rounds > 0 => break,
|
||||
None => {}
|
||||
}
|
||||
if left_out.is_empty() || left_out.len() >= faces.len() || rounds >= MAX_LEFT_OUT_ROUNDS {
|
||||
break;
|
||||
}
|
||||
rounds += 1;
|
||||
let skip: std::collections::HashSet<u64> = left_out.iter().map(|(f, _)| *f).collect();
|
||||
let read =
|
||||
solidcraft_profile::scope("import", "step.read_without", || solidcraft_step::topology::read_solid_without(ex, item, units, trims, &skip));
|
||||
match read.map_err(|msg| Failure { read: true, msg }).and_then(|solid| Ok((solid_part(&solid)?, solid.notes))) {
|
||||
Ok((mut part, mut notes)) => {
|
||||
part.file_faces = faces.len();
|
||||
part.refused = Some(refused.msg);
|
||||
notes.extend(left_out.iter().map(|(_, m)| format!("left out: {m}")));
|
||||
return Ok((part, notes));
|
||||
}
|
||||
Err(e) => {
|
||||
log::debug!(target: "step", "item #{item}: read without {} faces, refused: {}", skip.len(), e.msg);
|
||||
why = e.msg;
|
||||
}
|
||||
}
|
||||
}
|
||||
// The faces that read alone, each a one-face surface body.
|
||||
let mut notes = Vec::new();
|
||||
let mut pieces = Vec::with_capacity(faces.len());
|
||||
for f in &faces {
|
||||
match f.record.clone().map_err(KernelError::Failed).and_then(Body::from_record) {
|
||||
Ok(b) => pieces.push((f.face, b)),
|
||||
Err(e) => notes.push(format!("left out: {}", e.to_string().trim_start_matches("the operation failed: "))),
|
||||
}
|
||||
}
|
||||
match stitched_part(&pieces, faces.len(), &refused.msg) {
|
||||
Ok(part) => Ok((part, notes)),
|
||||
Err(e) => {
|
||||
log::debug!(target: "step", "item #{item}: its faces not stitched ({e}); meshed instead");
|
||||
mesh_part(&pieces, faces.len(), notes, refused)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The one-face surface bodies `pieces` (each with its file face) stitched by SMLib into one
|
||||
/// surface body, where their edges coincide within ten times the pieces' tolerance.
|
||||
fn stitched_part(pieces: &[(u64, Body)], file_faces: usize, refused: &str) -> crate::Result<Part> {
|
||||
if pieces.is_empty() {
|
||||
return Err(KernelError::Failed("no face read".into()));
|
||||
}
|
||||
let tol = 10.0 * pieces.iter().map(|(_, b)| b.record().tolerance).fold(0.0, f64::max);
|
||||
let bodies: Vec<&Body> = pieces.iter().map(|(_, b)| b).collect();
|
||||
let body = crate::surfaces::stitch(&bodies, tol)?;
|
||||
// Each stitched face is the one face of the piece it was sewn from.
|
||||
let history = body.history().ok_or_else(|| KernelError::Failed("the stitch kept no history".into()))?;
|
||||
let face_origin = history
|
||||
.faces
|
||||
.iter()
|
||||
.map(|f| match f.origins.as_slice() {
|
||||
[crate::history::FaceOrigin::Face { operand, .. }] => pieces.get(*operand).map(|(face, _)| *face),
|
||||
_ => None,
|
||||
})
|
||||
.collect::<Option<Vec<u64>>>()
|
||||
.filter(|o| o.len() == body.face_count())
|
||||
.ok_or_else(|| KernelError::Failed("a stitched face from no one face".into()))?;
|
||||
let closed = !body.is_surface();
|
||||
Ok(Part { body, closed, file_faces, face_origin, refused: Some(refused.to_string()) })
|
||||
}
|
||||
|
||||
/// The one-face surface bodies `pieces` meshed by the planner, their triangles together a mesh
|
||||
/// body: no B-rep (modelling operations refuse it), for a solid whose faces SMLib could not
|
||||
/// stitch either. Faces that cannot be meshed are left out, each named in the notes; with no
|
||||
/// face to show, the solid stays refused.
|
||||
fn mesh_part(
|
||||
pieces: &[(u64, Body)],
|
||||
file_faces: usize,
|
||||
mut notes: Vec<String>,
|
||||
refused: Failure,
|
||||
) -> std::result::Result<(Part, Vec<String>), Failure> {
|
||||
let _span = solidcraft_profile::span("import", "step.refused_mesh");
|
||||
// Every face at the display tolerance of the whole solid.
|
||||
let bounds: solidcraft_geom::Aabb3 = bodies.iter().flat_map(|(_, b)| b.record().vertices.iter().map(|v| crate::body::v3(v.point))).collect();
|
||||
let bounds: solidcraft_geom::Aabb3 = pieces.iter().flat_map(|(_, b)| b.record().vertices.iter().map(|v| crate::body::v3(v.point))).collect();
|
||||
let size = if bounds.is_empty() { 0.0 } else { bounds.diagonal() };
|
||||
let tol = crate::MeshTolerance::display_of(if size.is_finite() { size } else { 0.0 });
|
||||
let (mut positions, mut triangles) = (Vec::new(), Vec::new());
|
||||
for (face, b) in &bodies {
|
||||
for (face, b) in pieces {
|
||||
match b.mesh(&tol) {
|
||||
Ok(m) if !m.triangles.is_empty() => {
|
||||
let Ok(base) = u32::try_from(positions.len()) else { break };
|
||||
positions.extend_from_slice(&m.positions);
|
||||
triangles.extend(m.triangles.iter().map(|t| t.map(|i| i.saturating_add(base))));
|
||||
}
|
||||
Ok(_) => notes.push(format!("not shown: face #{face}: no triangles")),
|
||||
Err(e) => notes.push(format!("not shown: face #{face}: {}", e.to_string().trim_start_matches("the operation failed: "))),
|
||||
Ok(_) => notes.push(format!("left out: face #{face}: no triangles")),
|
||||
Err(e) => notes.push(format!("left out: face #{face}: {}", e.to_string().trim_start_matches("the operation failed: "))),
|
||||
}
|
||||
}
|
||||
if triangles.is_empty() {
|
||||
@@ -157,7 +312,7 @@ fn mesh_part(ex: &Exchange, item: u64, units: Units, refused: Failure) -> std::r
|
||||
let body = crate::meshbody::mesh_body(&positions, &triangles)
|
||||
.map_err(|e| Failure { msg: format!("{} (its mesh: {e})", refused.msg), read: refused.read })?;
|
||||
let closed = body.is_closed_mesh();
|
||||
Ok((Part { body, closed, file_faces: faces.len(), face_origin: Vec::new(), refused: Some(refused.msg) }, notes))
|
||||
Ok((Part { body, closed, file_faces, face_origin: Vec::new(), refused: Some(refused.msg) }, notes))
|
||||
}
|
||||
|
||||
/// Prepare `jobs`, the results in the jobs' order. Solids still to read and orient (the slow
|
||||
|
||||
Reference in new issue
Block a user