Skip to content

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

OBJ export: welded as STL and 3MF are, so a curved body opens again closed (#9074) (#9213)

austin62jakee4e3c8609c3b
diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rs
index 6e0455f679..2c8a37c7da 100644
--- a/crates/io/src/lib.rs
+++ b/crates/io/src/lib.rs
@@ -421,9 +421,14 @@ pub fn export_mesh_at(b: &solidcraft_kernel::Body, quality: MeshQuality) -> Resu
Ok(b.tessellate((b.size() * quality.share()).max(1e-3))?)
}
-/// Distance within which an exported mesh's vertices are welded (STL and 3MF alike).
+/// Distance within which an exported mesh's vertices are welded (STL, 3MF and OBJ alike).
fn weld_eps(b: &solidcraft_kernel::Body) -> f64 {
- (b.size() * 1e-6).max(1e-7)
+ weld_distance(b.size())
+}
+
+/// [`weld_eps`] for a body of characteristic size (bounding box diagonal) `size`.
+fn weld_distance(size: f64) -> f64 {
+ (size * 1e-6).max(1e-7)
}
/// Unit-density [`MassProperties`] of a body from its welded [`export_mesh`], the mesh URDF links
@@ -538,49 +543,81 @@ pub fn obj_files(bodies: &[ObjBody<'_>], mtl_name: &str) -> ObjFiles {
ObjFiles { obj, mtl }
}
-/// The mesh of a body: its vertices and normals, each written once per distinct value, and the
-/// faces that use them. Returns the text and the bases the next body carries on from.
+/// The mesh of a body, welded as STL and 3MF are ([`weld`]: vertices closer than
+/// [`weld_distance`] merged, and sides split where another face's vertex lies on them), so
+/// neighbouring faces share their edge points and the file opens again as a closed solid
+/// (#9074). Each corner keeps the normal it had ([`corner_normals`]), so edges between faces
+/// stay sharp. Vertices and normals are each written once per distinct value. Returns the text
+/// and the bases the next body carries on from.
fn mesh_text(mesh: &Mesh, vbase: usize, nbase: usize) -> (String, usize, usize) {
use std::collections::HashMap;
+ let mut bounds = solidcraft_geom::Aabb3::EMPTY;
+ for p in &mesh.positions {
+ bounds.add(*p);
+ }
+ let eps = weld_distance(bounds.diagonal());
+ // Each welded triangle is tagged with the triangle it came from, for its normals.
+ let source: Vec<u32> = (0..mesh.triangles.len()).map(|k| u32::try_from(k).unwrap_or(u32::MAX)).collect();
+ let (positions, triangles, from) = threemf::weld_tagged(&mesh.positions, &mesh.triangles, &source, eps);
let mut s = String::new();
+ for p in &positions {
+ s += &format!("v {} {} {}\n", p.x, p.y, p.z);
+ }
// `+ 0.0` turns -0 into 0, so both merge.
- let key = |x: f64, y: f64, z: f64| [x + 0.0, y + 0.0, z + 0.0].map(f64::to_bits);
- let mut vmap: HashMap<[u64; 3], usize> = HashMap::new();
+ let key = |n: Vec3| [n.x + 0.0, n.y + 0.0, n.z + 0.0].map(f64::to_bits);
let mut nmap: HashMap<[u64; 3], usize> = HashMap::new();
- let vi: Vec<usize> = mesh
- .positions
- .iter()
- .map(|p| {
- let next = vmap.len();
- *vmap.entry(key(p.x, p.y, p.z)).or_insert_with(|| {
- s += &format!("v {} {} {}\n", p.x, p.y, p.z);
- next
- })
- })
- .collect();
- let ni: Vec<usize> = mesh
- .normals
- .iter()
- .map(|n| {
+ let mut faces = String::new();
+ for (t, k) in triangles.iter().zip(&from) {
+ let (a, b, c) = (t[0] as usize + vbase, t[1] as usize + vbase, t[2] as usize + vbase);
+ let at = t.map(|i| positions.get(i as usize).copied());
+ let normals = match (mesh.triangles.get(*k as usize), at) {
+ (Some(o), [Some(pa), Some(pb), Some(pc)]) => corner_normals(mesh, *o, [pa, pb, pc], eps),
+ _ => None,
+ };
+ let Some(normals) = normals else {
+ faces += &format!("f {a} {b} {c}\n");
+ continue;
+ };
+ let [na, nb, nc] = normals.map(|n| {
let next = nmap.len();
- *nmap.entry(key(n.x, n.y, n.z)).or_insert_with(|| {
- s += &format!("vn {} {} {}\n", n.x, n.y, n.z);
- next
- })
- })
- .collect();
- for t in &mesh.triangles {
- let (Some(a), Some(b), Some(c)) = (vi.get(t[0] as usize), vi.get(t[1] as usize), vi.get(t[2] as usize)) else { continue };
- let (a, b, c) = (a + vbase, b + vbase, c + vbase);
- match (ni.get(t[0] as usize), ni.get(t[1] as usize), ni.get(t[2] as usize)) {
- (Some(na), Some(nb), Some(nc)) => {
- let (na, nb, nc) = (na + nbase, nb + nbase, nc + nbase);
- s += &format!("f {a}//{na} {b}//{nb} {c}//{nc}\n");
- }
- _ => s += &format!("f {a} {b} {c}\n"),
- }
+ nbase
+ + *nmap.entry(key(n)).or_insert_with(|| {
+ s += &format!("vn {} {} {}\n", n.x, n.y, n.z);
+ next
+ })
+ });
+ faces += &format!("f {a}//{na} {b}//{nb} {c}//{nc}\n");
}
- (s, vbase + vmap.len(), nbase + nmap.len())
+ s += &faces;
+ (s, vbase + positions.len(), nbase + nmap.len())
+}
+
+/// The normals at the corners `at` of a welded piece of triangle `t` of `mesh` (the whole
+/// triangle, or a piece of it split where another face's vertex lies on a side): a corner
+/// within `eps` of one of `t`'s own corners takes that corner's normal; a point a side was split
+/// at takes the normal between the side's ends. `None` when the mesh has no normals there.
+fn corner_normals(mesh: &Mesh, t: [u32; 3], at: [Vec3; 3], eps: f64) -> Option<[Vec3; 3]> {
+ let p = t.map(|i| mesh.positions.get(i as usize).copied());
+ let n = t.map(|i| mesh.normals.get(i as usize).copied());
+ let ([Some(p0), Some(p1), Some(p2)], [Some(n0), Some(n1), Some(n2)]) = (p, n) else { return None };
+ let (p, n) = ([p0, p1, p2], [n0, n1, n2]);
+ Some(at.map(|q| p.iter().zip(n).find(|(c, _)| c.dist(q) <= eps).map_or_else(|| normal_at(p, n, q), |(_, n)| n)))
+}
+
+/// The normal at `q` on the triangle with corners `p` and corner normals `n`: the corners'
+/// normals weighted by where `q` lies (barycentric), of unit length. The first corner's when
+/// the triangle has no area.
+fn normal_at(p: [Vec3; 3], n: [Vec3; 3], q: Vec3) -> Vec3 {
+ let [p0, p1, p2] = p;
+ let [n0, n1, n2] = n;
+ let (e1, e2, d) = (p1 - p0, p2 - p0, q - p0);
+ let (d11, d12, d22, d1, d2) = (e1.dot(e1), e1.dot(e2), e2.dot(e2), d.dot(e1), d.dot(e2));
+ let den = d11 * d22 - d12 * d12;
+ if !(den.abs() > 0.0) {
+ return n0;
+ }
+ let (v, w) = ((d22 * d1 - d12 * d2) / den, (d11 * d2 - d12 * d1) / den);
+ (n0 * (1.0 - v - w) + n1 * v + n2 * w).normalized().unwrap_or(n0)
}
/// The material of each body: its name, safe to write in a material library and unique among
@@ -1225,9 +1262,8 @@ mod tests {
.sum()
}
- /// Build → export 3MF → import → the same volume as the STL export, closed meshes, names.
- #[test]
- fn threemf_round_trip() {
+ /// A filleted box, a cylinder and a torus: bodies whose faces are curved and meshed apart.
+ fn curved_bodies() -> Model {
let mut doc = Document::new("t");
doc.add_feature(
FeatureKind::Box {
@@ -1276,6 +1312,40 @@ mod tests {
.unwrap();
let mut m = Model::new();
m.evaluate(&doc);
+ m
+ }
+
+ /// OBJ is welded as STL and 3MF are: a filleted box, a cylinder and a torus written as OBJ
+ /// open again closed, with their STL export's volume, every face keeping its normals
+ /// (#9074). Before, each face wrote its edge points again, a few ulps apart, and the file
+ /// opened as an open mesh with no volume.
+ #[test]
+ fn obj_round_trip_of_curved_bodies_is_closed() {
+ let m = curved_bodies();
+ let st = m.state();
+ let bytes = export(&st, &[], Format::Obj, "t").unwrap();
+ let text = String::from_utf8(bytes.clone()).unwrap();
+ assert!(text.lines().filter(|l| l.starts_with("f ")).all(|l| l.matches("//").count() == 3), "every corner has a normal");
+ let f = mesh_import_feature(&bytes, "parts.obj").unwrap();
+ let mut d2 = Document::new("m");
+ let id = d2.add_feature(f.kind, Some(&f.name)).unwrap();
+ let mut m2 = Model::new();
+ m2.evaluate(&d2);
+ assert!(m2.result(id).unwrap().error.is_none());
+ let st2 = m2.state();
+ assert_eq!(st2.bodies.len(), 3);
+ for (a, b) in st.bodies.iter().zip(&st2.bodies) {
+ assert!(b.body.is_mesh() && b.body.is_closed_mesh(), "{} is not watertight", a.name);
+ let v_stl = stl_volume(&export(&st, std::slice::from_ref(&a.name), Format::StlBinary, "t").unwrap());
+ let v = solidcraft_kernel::measure(&b.body).unwrap().volume;
+ assert!((v - v_stl).abs() <= 1e-6 * v_stl.abs(), "{}: {v} vs {v_stl}", a.name);
+ }
+ }
+
+ /// Build → export 3MF → import → the same volume as the STL export, closed meshes, names.
+ #[test]
+ fn threemf_round_trip() {
+ let m = curved_bodies();
let st = m.state();
assert_eq!(st.bodies.len(), 3);
let bytes = export(&st, &[], Format::ThreeMf, "t").unwrap();