Sheet metal: readable face names from the sheet itself (#2275)

Sheet metal faces get readable names (#2272).
This commit is contained in:
NOWN-DEV
2026-10-19 22:08:01 +02:00
committed by GitHub
parent 539c17b425
commit 473f1e6516
7 changed files with 311 additions and 1 deletions
+40
View File
@@ -260,6 +260,9 @@ impl EdgeHit {
/// answering to it (merged into it, or the named piece told apart by the faces around it); else
/// the piece of it nearest `p` (`split`).
pub fn locate_face(st: &ModelState, name: &str, p: Vec3) -> Option<FaceHit> {
if crate::sheet::split_sheet_face_name(name).is_some() {
return sheet_locate(st, name, p);
}
// Every body's names are read below: work out the ones not known yet on all cores first
// (each body's names are its own, whichever thread works them out).
if legacy_name(name).is_none() {
@@ -278,6 +281,9 @@ pub fn locate_face(st: &ModelState, name: &str, p: Vec3) -> Option<FaceHit> {
/// face), or on this body it names a piece of a split face or a merged one. The same face on
/// another body (a copy of this one) is not a piece of this body's face.
pub(crate) fn locate_face_on_body(st: &ModelState, body: Option<&str>, name: &str, p: Vec3) -> Option<FaceHit> {
if crate::sheet::split_sheet_face_name(name).is_some() {
return sheet_locate(st, name, p);
}
if legacy_name(name).is_none()
&& let Some(i) = body.and_then(|n| st.bodies.iter().position(|b| b.name == n))
&& let Some(b) = st.bodies.get(i).filter(|b| !b.body.is_mesh())
@@ -290,6 +296,30 @@ pub(crate) fn locate_face_on_body(st: &ModelState, body: Option<&str>, name: &st
locate_face(st, name, p)
}
/// [`locate_face`] for a sheet face's readable name (`sheet:<body>:<panel>:<side>`, see
/// [`crate::sheet::body_sheet_face_names`]): the face of that body the sheet names so, else the
/// piece of it nearest `p` (`split`). The sheet itself says which face it is, so the name holds
/// however the faces of the body are numbered.
fn sheet_locate(st: &ModelState, name: &str, p: Vec3) -> Option<FaceHit> {
let (body, _) = crate::sheet::split_sheet_face_name(name)?;
let (bi, b) = st.bodies.iter().enumerate().find(|(_, b)| b.name == body && !b.body.is_mesh())?;
let names = crate::sheet::body_sheet_face_names(st, b);
let faces: Vec<usize> = names.iter().enumerate().filter(|(_, n)| n.as_deref() == Some(name)).map(|(i, _)| i).collect();
let m = b.mesh();
let (distance, face, point) =
faces.iter().filter_map(|f| nearest_on_face(&m, *f, p).map(|(d, q)| (d, *f, q))).min_by(|a, c| a.0.total_cmp(&c.0))?;
Some(FaceHit {
body: bi,
face,
point,
split: faces.len() > 1,
merged: false,
verified: true,
on_point: distance <= (b.body.size() * 1e-3).max(1e-3),
legacy: false,
})
}
/// [`locate_face`] among `bodies` (with their indices).
fn locate_in<'a>(bodies: impl Iterator<Item = (usize, &'a ModelBody)>, name: &str, p: Vec3) -> Option<FaceHit> {
if let Some(old) = legacy_name(name) {
@@ -401,6 +431,16 @@ pub fn locate_one(st: &ModelState, body: Option<&str>, name: &str) -> Result<Fac
{
return Err(format!("no body `{n}`"));
}
if let Some((sheet_body, _)) = crate::sheet::split_sheet_face_name(name) {
if body.is_some_and(|n| n != sheet_body) {
return Err(format!("`{name}` is a face of `{sheet_body}`"));
}
let hit = sheet_locate(st, name, Vec3::ZERO).ok_or_else(|| format!("no face is named `{name}` (`model.faces` lists the names)"))?;
if hit.split {
return Err(format!("`{name}` names more than one face (pieces of a split face): give the name of one piece"));
}
return Ok(hit);
}
let bodies: Vec<(usize, &ModelBody)> =
st.bodies.iter().enumerate().filter(|(_, b)| !b.body.is_mesh() && body.is_none_or(|n| b.name == n)).collect();
// As [`locate_face`]: the names of several bodies are worked out on all cores first.
+3
View File
@@ -18,8 +18,11 @@ use crate::{DocError, Document, IDENTITY, Mat, Result, apply_point, apply_vector
#[path = "sheet_convert.rs"]
mod convert;
#[path = "sheet_face_names.rs"]
mod face_names;
pub use convert::{bend_edge_names, convert_body};
pub(crate) use convert::{outline_loop, round_wall};
pub use face_names::body_sheet_face_names;
// Bound the aggregate geometry, including sampled curves and intermediate clipping pieces.
// These are work limits, never geometry truncation: a larger input returns a useful error.
+131
View File
@@ -0,0 +1,131 @@
//! Readable names of a sheet metal body's faces, from the sheet itself: `<panel>:top`,
//! `<panel>:bottom` and `<panel>:rim.<edge>` (the names sketches on sheet faces keep, see
//! [`SheetBody::panel_face_at`]); a bend's curved faces, `<flange>:bend.inner` and
//! `<flange>:bend.outer`; and where a flange's panel runs on past its bend's ends (toward a
//! neighbouring flange), the rim along the bend there, `<flange>:rim.ext0` and `rim.ext1`. A panel is `base` or a flange's tag (`F<feature>.<k>`), so the names
//! say what each face is and stay with it when sizes change or other flanges come and go.
use solidcraft_geom::{Vec2, Vec3};
use super::SheetBody;
use crate::{ModelBody, ModelState, apply_point, mat_inverse};
/// The share of a face's sample points that must agree on a name for the face to take it.
const AGREE: f64 = 0.8;
impl SheetBody {
/// The readable name of the face of this sheet a point lies on (sheet coordinates, within
/// `tol`, kept below a quarter of the thickness): a flat face's (see
/// [`panel_face_at`](Self::panel_face_at)), else a bend's inner or outer face.
pub fn face_name_at(&self, p: Vec3, tol: f64) -> Option<String> {
self.panel_face_at(p, tol).map(|(name, _)| name).or_else(|| self.bend_face_at(p, tol)).or_else(|| self.ext_rim_at(p, tol))
}
/// The rim of a flange's panel along its bend line, where the panel runs on past the
/// bend's start (`<flange>:rim.ext0`) or end (`rim.ext1`).
fn ext_rim_at(&self, p: Vec3, tol: f64) -> Option<String> {
if self.flat {
return None;
}
let tol = tol.min(self.t * 0.25);
for (pi, region) in self.panels() {
let Some(i) = pi else { continue };
let Some(f) = self.flanges.get(i) else { continue };
let Some(inverse) = mat_inverse(&self.world(pi)) else { continue };
let q = apply_point(&inverse, p);
if q.z < -tol || q.z > self.t + tol {
continue;
}
let q2 = Vec2::new(q.x, q.y);
let pts = region.outer.ccw().polyline(1e-3);
let m = pts.len();
for k in 0..m {
let (Some(&a), Some(&b)) = (pts.get(k), pts.get((k + 1) % m)) else { continue };
let d = b - a;
if d.len2() < 1e-18 || self.rim_edge(pi, a, b, k).as_deref() != Some("bend") {
continue;
}
let along = (q2 - a).dot(d) / d.len2();
if !(-1e-9..=1.0 + 1e-9).contains(&along) || ((a + d * along) - q2).len() > tol {
continue;
}
let end = if (q2 - f.p).dot(f.d) < f.len / 2.0 { "ext0" } else { "ext1" };
return Some(format!("{}:rim.{end}", self.panel_name(pi)));
}
}
None
}
/// The curved face of a bend a point lies on: `<flange>:bend.inner` (the bend's radius) or
/// `<flange>:bend.outer` (the radius plus the thickness).
fn bend_face_at(&self, p: Vec3, tol: f64) -> Option<String> {
if self.flat {
return None;
}
let tol = tol.min(self.t * 0.25);
for (i, f) in self.flanges.iter().enumerate() {
let Some((world, o, d, start, toward)) = self.bend_frame(f) else { continue };
let Some(inverse) = mat_inverse(&world) else { continue };
let q = apply_point(&inverse, p) - o;
let u = q.dot(d);
let (u0, u1) = self.zone_span(f);
if u < u0 - tol || u > u1 + tol {
continue;
}
let radial = q - d * u;
let rho = radial.len();
let side = if (rho - f.radius).abs() <= tol {
"inner"
} else if (rho - f.radius - self.t).abs() <= tol {
"outer"
} else {
continue;
};
let phi = radial.dot(toward).atan2(radial.dot(start));
if phi < -1e-6 || phi > f.angle.abs() + 1e-6 {
continue;
}
return Some(format!("{}:bend.{side}", self.panel_name(Some(i))));
}
None
}
}
/// The readable sheet names of a body's faces (by B-rep face index), as
/// [`sheet_face_name`](super::sheet_face_name)s: `sheet:<body>:<panel>:<side>`. `None` for a face
/// the sheet does not name (a hole's wall, a pocket's floor) and for every face of a body that is
/// no folded sheet of `st`.
pub fn body_sheet_face_names(st: &ModelState, b: &ModelBody) -> Vec<Option<String>> {
let m = b.mesh();
let nf = m.tri_face.iter().map(|f| *f as usize + 1).max().unwrap_or(0);
let Some(sheet) = st.sheets.iter().find(|s| s.body == b.name && !s.flat) else { return vec![None; nf] };
// Triangle centres lie inside a face, off a curved one by its facets' sag: a fifth of the
// thickness takes them and still tells a flat face from the rim beside it.
let tol = sheet.t * 0.2;
let mut votes: Vec<Vec<(String, usize)>> = vec![Vec::new(); nf];
let mut total = vec![0usize; nf];
for (t, f) in m.triangles.iter().zip(&m.tri_face) {
let (Some(v), Some(n), Some([a, b2, c])) = (votes.get_mut(*f as usize), total.get_mut(*f as usize), m.tri(t)) else { continue };
// At most a few dozen points a face: enough to tell its name, cheap on a fine mesh.
if *n >= 48 {
continue;
}
*n += 1;
if let Some(name) = sheet.face_name_at((a + b2 + c) * (1.0 / 3.0), tol) {
match v.iter_mut().find(|(x, _)| *x == name) {
Some(x) => x.1 += 1,
None => v.push((name, 1)),
}
}
}
votes
.into_iter()
.zip(total)
.map(|(v, n)| {
v.into_iter()
.max_by_key(|x| x.1)
.filter(|(_, k)| *k as f64 >= AGREE * n.max(1) as f64)
.map(|(name, _)| super::sheet_face_name(&b.name, &name))
})
.collect()
}
+10 -1
View File
@@ -19,7 +19,9 @@ pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("model.edges", "List Edges", model_edges).icon("inspect").noundo().params("body: name"),
CommandSpec::new("model.faces", "List Faces", model_faces).icon("inspect").noundo().params(
"body: name → per face: index, name (what face.delete, sheet.convert `face`, solid.shell … take in place of a point), exact, area, centroid (not always on the face), \
plane_normal, point (a point on the face that picks it), cylinder? ({origin, axis, radius} of a cylindrical face)",
plane_normal, point (a point on the face that picks it), cylinder? ({origin, axis, radius} of a cylindrical face), \
sheet_face? (a folded sheet's face: `sheet:<body>:<panel>:<side>`, panel base or a flange's tag F<feature>.<k>, side top | bottom | rim.<edge> | bend.inner | bend.outer; \
taken wherever a face name is, and it holds while sizes change and flanges come and go)",
),
CommandSpec::new("model.threads", "List Threads", model_threads).icon("inspect").noundo(),
CommandSpec::new("material.assign", "Physical Material", physical_material)
@@ -291,6 +293,10 @@ fn model_faces(s: &mut Session, p: &Value) -> Result<Value> {
let names = solidcraft_doc::naming::face_names(b);
let tol = (b.body.size() * 2e-3).max(1e-3);
let spots = solidcraft_doc::naming::face_spots(b);
// A folded sheet's faces also have the readable names its sheet gives them, worked out in
// the body's own coordinates.
let model = s.model.state();
let sheet_names = model.body(&b.name).map(|own| solidcraft_doc::sheet::body_sheet_face_names(&model, own)).unwrap_or_default();
let faces: Vec<Value> = b
.body
.faces(tol)?
@@ -299,6 +305,9 @@ fn model_faces(s: &mut Session, p: &Value) -> Result<Value> {
let spot = spots.get(f.index).copied().flatten();
let mut v = json!({"index": f.index, "name": names.get(f.index), "exact": solidcraft_doc::naming::face_name_exact(b, f.index),
"area": f.area, "centroid": f.centroid, "plane_normal": f.plane_normal, "point": spot.map(|x| x.point)});
if let (Some(Some(name)), Some(o)) = (sheet_names.get(f.index), v.as_object_mut()) {
o.insert("sheet_face".into(), json!(name));
}
if let (Some(solidcraft_kernel::FaceSurface::Cylinder { origin, axis, radius }), Some(o)) =
(spot.and_then(|x| x.surface), v.as_object_mut())
{
+4
View File
@@ -904,3 +904,7 @@ mod convert_tests;
#[cfg(test)]
#[path = "sheet_dxf_tests.rs"]
mod dxf_tests;
#[cfg(test)]
#[path = "sheet_face_names_tests.rs"]
mod face_names_tests;
@@ -0,0 +1,114 @@
use serde_json::{Value, json};
use solidcraft_geom::Vec3;
use crate::Session;
fn run(s: &mut Session, id: &str, p: Value) -> Value {
match s.execute(id, &p) {
Ok(v) => v,
Err(e) => panic!("{id} {p}: {e}"),
}
}
/// A tray: a base `w` x 200 (its width a sketch dimension: the parameter returned), 1 mm thick
/// with 1 mm bends, front and back flanges 30 high in one feature, left and right in another,
/// and a 6.6 mm hole in the base: the two flange features' ids.
fn tray(s: &mut Session, w: f64) -> (String, u64, u64) {
run(s, "sheet.manage_rules", json!({"name": "R1", "thickness": "1 mm", "bend_radius": "1 mm", "active": true}));
run(s, "sketch.create", json!({"plane": "XY", "name": "Base"}));
run(s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [w, 200]}));
let d = run(s, "sketch.dimension", json!({"entities": ["l1"], "value": w}));
run(s, "sketch.finish", json!({}));
run(s, "sheet.flange", json!({"sketch": "Base"}));
run(s, "sheet.flange", json!({"edges": [[100, 0, 1], [100, 200, 1]], "height": 30}));
let front_back = s.doc.features.last().map_or(0, |f| f.id);
run(s, "sheet.flange", json!({"edges": [[0, 100, 1], [w, 100, 1]], "height": 30}));
let sides = s.doc.features.last().map_or(0, |f| f.id);
run(s, "solid.hole", json!({"position": [100, 100, 1], "diameter": 6.6}));
let param = d["param"].as_str().or_else(|| d["name"].as_str()).map(str::to_string).unwrap_or_else(|| "d1".into());
(param, front_back, sides)
}
/// Each face's readable sheet name, with its centroid and cylinder radius.
fn faces(s: &mut Session) -> Vec<(Option<String>, Vec3, Option<f64>)> {
let body = s.model.state().bodies.first().map(|b| b.name.clone()).unwrap_or_default();
let r = run(s, "model.faces", json!({"body": body}));
r["faces"]
.as_array()
.into_iter()
.flatten()
.map(|f| {
let c = &f["centroid"];
let at = Vec3::new(c[0].as_f64().unwrap_or(f64::NAN), c[1].as_f64().unwrap_or(f64::NAN), c[2].as_f64().unwrap_or(f64::NAN));
(f["sheet_face"].as_str().map(str::to_string), at, f["cylinder"]["radius"].as_f64())
})
.collect()
}
fn named<'a>(faces: &'a [(Option<String>, Vec3, Option<f64>)], name: &str) -> Vec<&'a (Option<String>, Vec3, Option<f64>)> {
faces.iter().filter(|f| f.0.as_deref() == Some(name)).collect()
}
/// The point on the face with this name, as a command taking a face name finds it.
fn point(s: &Session, name: &str) -> Vec3 {
solidcraft_doc::naming::named_face_point(&s.model.state(), None, name).unwrap_or_else(|e| panic!("{name}: {e}"))
}
#[test]
fn a_trays_faces_have_readable_sheet_names_that_follow_its_size() {
let mut s = Session::default();
let (width, fb, sd) = tray(&mut s, 320.0);
let all = faces(&mut s);
// Every face but the hole's wall (two halves) has a sheet name, and no two faces share one.
let unnamed: Vec<_> = all.iter().filter(|f| f.0.is_none()).collect();
assert!(unnamed.len() == 2 && unnamed.iter().all(|f| f.2.is_some_and(|r| (r - 3.3).abs() < 1e-6)), "only the hole's wall: {unnamed:?}");
let mut names: Vec<&str> = all.iter().filter_map(|f| f.0.as_deref()).collect();
names.sort_unstable();
let n = names.len();
names.dedup();
assert_eq!(names.len(), n, "{names:?}");
for (name, at) in [
("sheet:Body1:base:top".to_string(), Vec3::new(160.0, 100.0, 1.0)),
("sheet:Body1:base:bottom".to_string(), Vec3::new(160.0, 100.0, 0.0)),
(format!("sheet:Body1:F{sd}.1:top"), Vec3::new(319.0, 100.0, 16.0)),
(format!("sheet:Body1:F{sd}.1:bottom"), Vec3::new(320.0, 100.0, 16.0)),
(format!("sheet:Body1:F{sd}.1:rim.far"), Vec3::new(319.5, 100.0, 30.0)),
(format!("sheet:Body1:F{fb}.0:bottom"), Vec3::new(160.0, 0.0, 16.0)),
// The front flange runs on past its bend to the right one, under its corner.
(format!("sheet:Body1:F{fb}.0:rim.ext1"), Vec3::new(319.0, 0.5, 2.0)),
] {
let f = named(&all, &name);
assert!(f.len() == 1 && f[0].1.dist(at) < 2.5, "{name}: {f:?}");
}
// A bend's two curved faces: its radius and the radius plus the thickness.
let radius = |name: &str| named(&all, name).first().and_then(|f| f.2);
assert_eq!(radius(&format!("sheet:Body1:F{fb}.0:bend.inner")).map(|r| (r * 1e6).round() / 1e6), Some(1.0));
assert_eq!(radius(&format!("sheet:Body1:F{fb}.0:bend.outer")).map(|r| (r * 1e6).round() / 1e6), Some(2.0));
// 80 mm wider: the same names, each on the same face where it now is.
let right = point(&s, &format!("sheet:Body1:F{sd}.1:top"));
assert!((right.x - 319.0).abs() < 1e-3, "{right:?}");
run(&mut s, "parameters.change", json!({"name": width, "expression": "400"}));
let wider = faces(&mut s);
let mut again: Vec<&str> = wider.iter().filter_map(|f| f.0.as_deref()).collect();
again.sort_unstable();
assert_eq!(again, names);
let right = point(&s, &format!("sheet:Body1:F{sd}.1:top"));
assert!((right.x - 399.0).abs() < 1e-3, "{right:?}");
let far = point(&s, &format!("sheet:Body1:F{fb}.1:rim.far"));
assert!((far.y - 199.5).abs() < 1e-3 && (far.z - 30.0).abs() < 1e-3, "{far:?}");
}
#[test]
fn a_flanges_sheet_names_hold_when_another_flange_goes() {
let mut s = Session::default();
let (_, fb, sd) = tray(&mut s, 320.0);
let right = format!("sheet:Body1:F{sd}.1:top");
let before = point(&s, &right);
run(&mut s, "timeline.suppress", json!({"feature": fb, "suppressed": true}));
let after = point(&s, &right);
assert!((after.x - 319.0).abs() < 1e-3 && (after.z - before.z).abs() < 16.0, "{before:?} {after:?}");
// The names of the flanges that went are gone; asking for one says so.
let gone = format!("sheet:Body1:F{fb}.0:top");
assert!(solidcraft_doc::naming::named_face_point(&s.model.state(), None, &gone).is_err());
assert!(solidcraft_doc::naming::named_face_point(&s.model.state(), Some("Body2"), &right).is_err());
}
+9
View File
@@ -312,3 +312,12 @@ flat pattern and its DXF have it, and on the bottom face y runs the other way, a
below. When the face is gone (its flange is suppressed or deleted) the sketch reports a lost
attachment instead of moving to another face; **Redefine Sketch Plane** attaches it to another
face. `fixed: true` still freezes the picked plane in space.
Every face of a folded sheet has a name of that kind, which `model.faces` lists as `sheet_face`:
`<panel>:top` and `<panel>:bottom`, `<panel>:rim.<edge>` for a rim (a base sketch line's id, or a
flange's `far`, `side0`, `side1`; `rim.bend0`/`rim.bend1` for a bend's flat ends and
`rim.ext0`/`rim.ext1` where a flange runs on past its bend toward a neighbour), and
`<flange>:bend.inner` / `<flange>:bend.outer` for a bend's curved faces. A command that takes a
face name takes it too (`sheet:Body1:F3.1:top`), and finds the face from the sheet itself, so the
name stays with that face while the sheet's sizes change and other flanges come and go. Faces the
sheet does not describe (a hole's wall) have none.