Skip to content

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

Persistent naming: shell inner faces named after the wall face they offset (F<shell>:inner:<face>), sweep and loft faces by start/end caps and the profile curve each side sweeps

bherbruck23e50e454020
diff --git a/crates/doc/src/naming.rs b/crates/doc/src/naming.rs
index 091adef26e..bbf71318b5 100644
--- a/crates/doc/src/naming.rs
+++ b/crates/doc/src/naming.rs
@@ -226,7 +226,14 @@ fn derive(b: &ModelBody, o: &NamingOrigin, nf: usize) -> Vec<String> {
.enumerate()
.map(|(fi, n)| {
n.unwrap_or_else(|| {
- role_name(&o.feature, &o.before, pts.get(fi).map(Vec::as_slice).unwrap_or(&[]), ns.get(fi).unwrap_or(&empty), fi, fid)
+ let (ps, nn) = (pts.get(fi).map(Vec::as_slice).unwrap_or(&[]), ns.get(fi).unwrap_or(&empty));
+ // A shell's inner face: the face its wall runs back to.
+ if matches!(o.feature.kind, FeatureKind::Shell { .. })
+ && let Some(n) = behind(ps, nn, &inputs)
+ {
+ return format!("F{fid}:inner:{}", strip_piece(&n));
+ }
+ role_name(&o.feature, &o.before, ps, nn, fi, fid)
})
})
.collect();
@@ -234,6 +241,59 @@ fn derive(b: &ModelBody, o: &NamingOrigin, nf: usize) -> Vec<String> {
names
}
+/// The input face a face looks back at through the material (along minus its normal): the
+/// face a shell wall's inner side offsets.
+fn behind(ps: &[Vec3], ns: &[Vec3], inputs: &[(&ModelBody, FaceIndex, Arc<Vec<String>>)]) -> Option<String> {
+ let n = ns.first().copied()?;
+ let d = n * -1.0;
+ let mut votes: Vec<(String, usize)> = Vec::new();
+ for p in ps {
+ let mut best: Option<(f64, String)> = None;
+ for (_, idx, nm) in inputs {
+ for (fi, (_, _, tris)) in idx.faces.iter().enumerate() {
+ for [a, b, c] in tris {
+ if let Some(t) = ray_hit(*p, d, *a, *b, *c)
+ && t > 1e-9
+ && best.as_ref().is_none_or(|(bt, _)| t < *bt)
+ && let Some(name) = nm.get(fi)
+ {
+ best = Some((t, name.clone()));
+ }
+ }
+ }
+ }
+ if let Some((_, n)) = best {
+ match votes.iter_mut().find(|(v, _)| *v == n) {
+ Some(v) => v.1 += 1,
+ None => votes.push((n, 1)),
+ }
+ }
+ }
+ votes.sort_by(|a, b| b.1.cmp(&a.1));
+ votes.first().filter(|(_, k)| *k * 2 >= ps.len().max(1)).map(|(n, _)| n.clone())
+}
+
+fn ray_hit(o: Vec3, d: Vec3, a: Vec3, b: Vec3, c: Vec3) -> Option<f64> {
+ let (e1, e2) = (b - a, c - a);
+ let h = d.cross(e2);
+ let det = e1.dot(h);
+ if det.abs() < 1e-14 {
+ return None;
+ }
+ let f = 1.0 / det;
+ let s = o - a;
+ let u = f * s.dot(h);
+ if !(0.0..=1.0).contains(&u) {
+ return None;
+ }
+ let q = s.cross(e1);
+ let v = f * d.dot(q);
+ if v < 0.0 || u + v > 1.0 {
+ return None;
+ }
+ Some(f * e2.dot(q))
+}
+
/// The input face most of a face's sample points lie on (mapped by `map` first), if it holds
/// at least half of them.
fn vote(ps: &[Vec3], inputs: &[(&ModelBody, FaceIndex, Arc<Vec<String>>)], tol: f64, map: Option<&crate::Mat>) -> Option<String> {
@@ -382,6 +442,27 @@ fn role_name(f: &Feature, before: &ModelState, ps: &[Vec3], ns: &[Vec3], fi: usi
.min_by(|a, b| a.0.total_cmp(&b.0));
best.map(|(_, id)| format!("F{fid}:side:{id}")).unwrap_or_else(|| format!("F{fid}:face:{fi}"))
}
+ FeatureKind::Sweep { .. } | FeatureKind::Loft { .. } => {
+ let sk = match &f.kind {
+ FeatureKind::Sweep { sketch, .. } => Some(*sketch),
+ FeatureKind::Loft { sections, .. } => sections.first().map(|x| x.sketch),
+ _ => None,
+ };
+ let Some(ss) = sk.and_then(|k| before.sketch(k)) else { return format!("F{fid}:face:{fi}") };
+ let n = ss.plane.normal();
+ let h = |p: &Vec3| (*p - ss.plane.origin).dot(n);
+ let flat = !ns.is_empty() && ns.windows(2).all(|w| w[0].cross(w[1]).len() < 1e-6);
+ if flat && ps.iter().all(|p| h(p).abs() < 1e-6 * (1.0 + p.len())) {
+ return format!("F{fid}:start");
+ }
+ if flat && ns.iter().all(|m| m.cross(n).len() < 1e-6) {
+ return format!("F{fid}:end");
+ }
+ // A side: the profile curve under its sample nearest the start.
+ let Some(p0) = ps.iter().min_by(|a, b| h(a).abs().total_cmp(&h(b).abs())) else { return format!("F{fid}:face:{fi}") };
+ let q = ss.plane.to_local(*p0);
+ nearest_curve(ss, Vec2::new(q.x, q.y)).map(|id| format!("F{fid}:side:{id}")).unwrap_or_else(|| format!("F{fid}:face:{fi}"))
+ }
FeatureKind::Box { .. } => {
let n = ns.first().copied().unwrap_or(Vec3::Z);
let axis = |v: f64, p: &str, m: &str| {
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 45864e88e6..b4bac4fba8 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -1355,6 +1355,17 @@ mod naming {
assert_eq!(sk.map(|z| (z * 1e6).round() / 1e6), Some(10.0));
}
+ #[test]
+ fn shell_inner_faces_are_named_after_the_walls() {
+ let mut s = Session::default();
+ run(&mut s, "PrimitiveBox", json!({"length": 40, "width": 30, "height": 20, "body_name": "B"}));
+ run(&mut s, "FusionShellBodyCommand", json!({"faces": [[20, 15, 20]], "thickness": 2}));
+ let n = face_names(&mut s, "B");
+ for want in ["F2:inner:F1:-z", "F2:inner:F1:+x", "F2:inner:F1:-x", "F2:inner:F1:+y", "F2:inner:F1:-y"] {
+ assert!(n.contains(&want.to_string()), "{want} in {n:?}");
+ }
+ }
+
#[test]
fn shell_and_hole_faces_follow_by_name() {
let mut s = Session::default();