SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Reconstruct constant-section meshes as parametric solids
lillithdf4c8a2994e9
diff --git a/README.md b/README.mdindex cf3b934016..0ea28d8f03 100644--- a/README.md+++ b/README.md@@ -77,7 +77,8 @@ renamed repository; old-name Pages and Flatpak URLs are not maintained as permancomponents as assemblies; revolved faces as native planes, cylinders, cones, spheres and tori),IGES 5.3 (manifold solid B-reps with names and colours), 3MF, STL (binary/ASCII) and OBJ;3MF, STL and OBJ import as mesh bodies (they render, measure, move and export; solid features- need B-rep bodies);+ need B-rep bodies). Convert Mesh reconstructs supported closed constant-section parts+ as parametric solids with planar and circular cylindrical faces;STEP import (AP203/AP214/AP242 solids, assemblies, units, names, colours) and IGES import(manifold solid B-reps, or trimmed and bounded surfaces sewn into solids) as a base featurethat later features build on — open a `.step`/`.stp`/`.igs`/`.iges` file, insert one into adiff --git a/ROADMAP.md b/ROADMAP.mdindex be98a93271..f8434677a7 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -49,7 +49,7 @@ headline counts in-scope tabs only and lists the deferred ones separately.| M1 | Sketch depth: command coverage implemented — projection/intersect/include as linked geometry (auto-project on faces, lost-reference warnings, break link), full SKETCH create/modify set (slots, polygons, tangent arcs/circles, ellipse, fit/control splines, conic, text, trim/extend/break, fillet/chamfer, offset, mirror, patterns, move/scale, blend curve, centerline), constraints incl. curvature and polygon with over-constraint refusal, driven/arc-length/linear-diameter dimensions, AutoConstrain, DXF/SVG insert, 3D sketch curves (Project To Surface, Intersection Curve, Isoparametric Curve, Spun Profile), exact free-form profiles (B-spline/NURBS edges, any spline degree, curves cut by crossings), sweeps and pipes along 3D sketch curves, canvases and decals, curvature combs. Exact free-form Extend and certified associative offsets now preserve geometry and IDs through edits, deletion and reopen. Occurrence-frame 3D wires now store explicit coordinate spaces and retain points and analytic fits through moves, refresh, undo and reopen. Remaining workflow repairs: mixed offset junctions, legacy natural-spline seams, and damaged legacy wire links lacking frame provenance | in progress | 4 || M2 | Robust modelling: coplanar booleans in the kernel, holes (placed on faces and on sketch points), threads (cosmetic, then modelled), patterns, mirror, shell, draft, split, construction geometry | in progress | 16 || M3 | General fillets and chamfers (curved edges, chains, vertex blends); saddle rolling-ball surfaces now use continuous seam sections and arc-length fitting with shared contact boundaries and bounded accuracy checks | in progress | 30 |-| M4 | Files: STEP import (done: all 29 Fusion STEP files — [docs/step-import.md](docs/step-import.md)), 3MF export and 3MF/STL import as mesh bodies (done), DXF sketches, OBJ import | in progress | 6 |+| M4 | Files: STEP import (done: all 29 Fusion STEP files — [docs/step-import.md](docs/step-import.md)), 3MF export and 3MF/STL import as mesh bodies (done), constant-section parametric mesh reconstruction, DXF sketches, OBJ import | in progress | 6 || M5 | Persistent naming of faces and edges (plan/adr/0002): faces named from their history (sketch curve sides, caps, revolve sections, primitive sides, blends, pattern/mirror copies; split pieces numbered), edges by their faces; fillets/chamfers, sketches on faces, shell/draft/offset/replace faces, hole placements, joint origins and face appearances resolve by name first and warn when the entity split or vanished: done. sheet metal edges by base sketch line and flange side, shell inner faces, sweep and loft roles: done. Left: kernel-reported face history (exact through coincident surfaces) | in progress | 20 || M6 | UI depth: selection feedback and origin (done), timeline editing (done: hover and selection highlight modifier faces, including fillets and chamfers; edit feature, history marker drag, reorder with dependency checks, suppress, rename, delete with dependents, re-resolved references; redefining selections refreshes persistent edge/face references while retaining feature identity and dimension names), right-docked dialogs (done), live previews for every feature dialog (done), keyboard-first commands with on-canvas value boxes and sketch inline dimensions (done), drag manipulators with automatic join/cut (done: extrude incl. two sides, fillet, shell, hole depth, move, pattern spacing, revolve rotator; taper handle open), dark theme (done), right-click menu with Repeat (done), measure tool (done), section analysis (done), selection filter (done), drag-solve of sketch points (done); appearance controls now preserve body/face/component targeting, named transparent looks, reuse/search and override removal; preferences | in progress | 6 || M7 | Sweep, loft (incl. to a point), rib and web (to next / depth), emboss (planar faces and exact radial emboss/deboss of bounded orthogonal profiles on complete exterior cylinders/sleeves), thread (cosmetic, and modelled M3–M20 outside and inside: the ISO profile screwed in as a faceted cut), coil (smooth B-spline helical walls), pipe, pattern on path, patterns of bodies and components, replace face (parallel), align, remove, feature copy/paste: done. Unique eligible cylindrical targets are inferred for new Emboss features. Left: general curved-face emboss and exact (unfaceted) modelled threads | in progress | 12 |diff --git a/crates/doc/src/assembly.rs b/crates/doc/src/assembly.rsindex f284d5fac9..b8924d45da 100644--- a/crates/doc/src/assembly.rs+++ b/crates/doc/src/assembly.rs@@ -329,6 +329,7 @@ impl FeatureKind {| FeatureKind::Thicken { .. }| FeatureKind::Import { .. }| FeatureKind::MeshImport { .. }+ | FeatureKind::MeshConvert { .. }| FeatureKind::BodyTransfer { .. } => {}FeatureKind::Patch { edges, .. } | FeatureKind::SurfaceExtend { edges, .. } => edges.iter_mut().for_each(pt),FeatureKind::SurfaceTrim { plane, tool, keep, .. } => {diff --git a/crates/doc/src/clipboard.rs b/crates/doc/src/clipboard.rsindex e60c2c7cac..22837e8c64 100644--- a/crates/doc/src/clipboard.rs+++ b/crates/doc/src/clipboard.rs@@ -356,9 +356,11 @@ impl crate::Feature {mapped_name(n, bodies);}}- K::Split { body, .. } | K::SheetConvert { body, .. } | K::SurfaceExtend { body, .. } | K::SurfaceTrim { body, .. } => {- mapped_name(body, bodies)- }+ K::Split { body, .. }+ | K::SheetConvert { body, .. }+ | K::SurfaceExtend { body, .. }+ | K::SurfaceTrim { body, .. }+ | K::MeshConvert { body, .. } => mapped_name(body, bodies),_ => {}}match &mut self.kind {diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rsindex 41cff42aee..d863a0526a 100644--- a/crates/doc/src/document.rs+++ b/crates/doc/src/document.rs@@ -883,8 +883,12 @@ pub enum FeatureKind {#[serde(default, skip_serializing_if = "Vec::is_empty")]components: Vec<solvecraft_kernel::StepNode>,},- /// A non-parametric base feature: mesh bodies imported from a 3MF or STL file (kept in the- /// design). Mesh bodies render, measure, move and export; solid features cannot use them.+ /// Rebuild an upstream constant-section mesh with analytic planar/cylindrical faces.+ MeshConvert {+ body: String,+ tolerance: String,+ },+ /// Mesh bodies imported from a 3MF or STL file, embedded in the design.MeshImport {/// Source file name (display only).file: String,@@ -1162,6 +1166,7 @@ impl FeatureKind {| K::Move { .. }| K::Import { .. }| K::MeshImport { .. }+ | K::MeshConvert { .. }| K::BodyTransfer { .. } => Vec::new(),}}@@ -1247,6 +1252,7 @@ impl FeatureKind {FeatureKind::SurfaceExtend { .. } => "ExtendFeature",FeatureKind::Import { .. } => "BaseFeature",FeatureKind::MeshImport { .. } => "MeshFeature",+ FeatureKind::MeshConvert { .. } => "MeshConvertFeature",}}/// Default name prefix (`Extrude` → `Extrude1`).@@ -1312,6 +1318,7 @@ impl FeatureKind {FeatureKind::SurfaceExtend { .. } => "Extend",FeatureKind::Import { .. } => "Import",FeatureKind::MeshImport { .. } => "Mesh",+ FeatureKind::MeshConvert { .. } => "ConvertMesh",}}/// Every expression the feature uses.@@ -1520,6 +1527,7 @@ impl FeatureKind {FeatureKind::ReplaceFace { target, .. } => plane_exprs(target, &mut v),FeatureKind::Align { .. } | FeatureKind::Remove { .. } | FeatureKind::BoundaryFill { .. } | FeatureKind::DeleteFace { .. } => {}FeatureKind::Stitch { tolerance, .. } => v.push(tolerance),+ FeatureKind::MeshConvert { tolerance, .. } => v.push(tolerance),FeatureKind::Thicken { thickness, .. } => v.push(thickness),FeatureKind::SurfaceTrim { plane, .. } => plane_exprs(plane, &mut v),FeatureKind::SurfaceExtend { distance, .. } => v.push(distance),diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex ed6c69d85f..fd76266a75 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -3299,6 +3299,20 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:}Ok(())}+ FeatureKind::MeshConvert { body, tolerance } => {+ let tolerance = val(vals, tolerance, Kind::Length)?;+ let index = st.bodies.iter().position(|b| &b.name == body).ok_or_else(|| DocError::Unknown(format!("body `{body}`")))?;+ let source = st.bodies.get(index).ok_or_else(|| DocError::Unknown(format!("body `{body}`")))?;+ if doc.model_body_component(source) != f.component {+ return Err(DocError::Invalid("activate the mesh body's component before converting it".into()));+ }+ let converted = kernel::convert_prismatic_mesh(&source.body, tolerance)?;+ let converted = converted.with_color(source.body.color());+ let result = ModelBody::new(source.name.clone(), converted, f.id);+ let target = st.bodies.get_mut(index).ok_or_else(|| DocError::Unknown(format!("body `{body}`")))?;+ *target = result;+ Ok(())+ }FeatureKind::MeshImport { meshes, .. } => {for (k, (name, b)) in mesh_bodies(meshes)?.into_iter().enumerate() {let name = copy_body_name(st, f, k, &name);diff --git a/crates/doc/src/params.rs b/crates/doc/src/params.rsindex c1b54110bc..f9309c9e50 100644--- a/crates/doc/src/params.rs+++ b/crates/doc/src/params.rs@@ -259,6 +259,7 @@ impl FeatureKind {}FeatureKind::ReplaceFace { target, .. } => plane_inputs_mut(target, &mut v),FeatureKind::Stitch { tolerance, .. } => v.push(("Tolerance", tolerance, L)),+ FeatureKind::MeshConvert { tolerance, .. } => v.push(("Tolerance", tolerance, L)),FeatureKind::Thicken { thickness, .. } => v.push(("Thickness", thickness, L)),FeatureKind::SurfaceTrim { plane, .. } => plane_inputs_mut(plane, &mut v),FeatureKind::SurfaceExtend { distance, .. } => v.push(("Distance", distance, L)),diff --git a/crates/engine/src/cmd/mesh.rs b/crates/engine/src/cmd/mesh.rsnew file mode 100644index 0000000000..1e72e88920--- /dev/null+++ b/crates/engine/src/cmd/mesh.rs@@ -0,0 +1,37 @@+//! Parametric reconstruction of imported mechanical mesh bodies.++use serde_json::Value;+use solvecraft_doc::FeatureKind;+use solvecraft_doc::expr::Kind;++use super::{+ CommandSpec,+ features::{add_feature, check_expr},+};+use crate::{+ Result, Session,+ params::{bad, expr, str_},+};++pub static COMMANDS: &[CommandSpec] = &[+ CommandSpec::new("mesh.convert", "Convert Mesh", convert)+ .at("MESH", "MODIFY")+ .icon("import")+ .params("body: mesh body name; tolerance?: length expression (default 0.05 mm): reconstruct a closed constant-section mechanical mesh as editable planar and cylindrical faces, with a parametric timeline feature; name?"),+];++fn convert(s: &mut Session, p: &Value) -> Result<Value> {+ let cmd = "mesh.convert";+ let body = str_(p, "body").filter(|b| !b.trim().is_empty()).ok_or_else(|| bad(cmd, "select a mesh body"))?;+ let state = s.model.state();+ let source = state.body(body).ok_or_else(|| bad(cmd, format!("no body `{body}`")))?;+ if !source.body.is_mesh() {+ return Err(bad(cmd, "select a mesh body"));+ }+ if s.doc.model_body_component(source) != s.active_component {+ return Err(bad(cmd, "activate the mesh body's component before converting it"));+ }+ let tolerance = expr(p, "tolerance").unwrap_or_else(|| "0.05 mm".into());+ check_expr(s, &tolerance, Kind::Length, cmd, "tolerance")?;+ add_feature(s, p, FeatureKind::MeshConvert { body: body.into(), tolerance })+}diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rsindex 426389bb5a..f825d095e0 100644--- a/crates/engine/src/cmd/mod.rs+++ b/crates/engine/src/cmd/mod.rs@@ -26,6 +26,7 @@ mod file;mod inspect;pub(crate) mod joints;mod measure_sel;+mod mesh;pub(crate) mod motion;mod parts;mod section;@@ -157,6 +158,7 @@ pub fn command_specs() -> Vec<&'static CommandSpec> {v.extend(sketch_project::COMMANDS.iter());v.extend(features::COMMANDS.iter());v.extend(features_more::COMMANDS.iter());+ v.extend(mesh::COMMANDS.iter());v.extend(construct::COMMANDS.iter());v.extend(sheet::COMMANDS.iter());v.extend(plastic::COMMANDS.iter());diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex 8de28a940c..b6ba6ed228 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -4,6 +4,8 @@ use serde_json::{Value, json};use crate::*;+mod mesh_convert;+fn run(s: &mut Session, id: &str, p: Value) -> Value {match s.execute(id, &p) {Ok(v) => v,diff --git a/crates/engine/src/tests/mesh_convert.rs b/crates/engine/src/tests/mesh_convert.rsnew file mode 100644index 0000000000..14193df7d3--- /dev/null+++ b/crates/engine/src/tests/mesh_convert.rs@@ -0,0 +1,93 @@+use super::*;+use solvecraft_doc::{Document, FeatureKind, MeshData};+use solvecraft_geom::Vec3;++fn imported_box() -> Session {+ let body = solvecraft_kernel::box_solid(Vec3::ZERO, Vec3::new(10., 20., 30.)).unwrap();+ let mesh = body.tessellate(0.01).unwrap();+ let mut doc = Document::default();+ doc.add_feature(+ FeatureKind::MeshImport {+ file: "public-safe-box.stl".into(),+ meshes: vec![MeshData {+ name: "Mesh".into(),+ positions: mesh.positions.iter().flat_map(|p| [p.x, p.y, p.z]).collect(),+ triangles: mesh.triangles.iter().flatten().copied().collect(),+ color: Some([0.2, 0.5, 0.8]),+ }],+ },+ Some("Imported mesh"),+ )+ .unwrap();+ Session::new(doc)+}++#[test]+fn mesh_conversion_is_parametric_undoable_and_editable_after_cold_reopen() {+ let mut s = imported_box();+ run(&mut s, "parameters.add", json!({"name":"size","expression":"1","unit":""}));+ run(&mut s, "solid.scale", json!({"bodies":["Mesh"],"factor":"size","name":"Mesh scale"}));+ run(&mut s, "mesh.convert", json!({"body":"Mesh","tolerance":"0.01 mm","name":"Reconstructed prism"}));+ let check = |s: &Session| {+ let state = s.model.state();+ let body = &state.body("Mesh").unwrap().body;+ assert!(!body.is_mesh());+ assert_eq!(body.faces(0.01).unwrap().len(), 6);+ assert_eq!(body.color(), Some([0.2, 0.5, 0.8]));+ assert!(s.model.results.iter().all(|r| r.error.is_none()), "{:?}", s.model.results);+ };+ check(&s);+ assert!((volume(&mut s) - 6000.).abs() < 1e-6);+ run(&mut s, "edit.undo", json!({}));+ assert!(s.model.state().body("Mesh").unwrap().body.is_mesh());+ run(&mut s, "edit.redo", json!({}));+ check(&s);+ run(&mut s, "parameters.change", json!({"name":"size","expression":"2"}));+ check(&s);+ assert!((volume(&mut s) - 48000.).abs() < 1e-5);+ let mut cold = Session::new(Document::from_json(&s.doc.to_json()).unwrap());+ check(&cold);+ assert!((volume(&mut cold) - 48000.).abs() < 1e-5);+ run(&mut cold, "solid.fillet", json!({"body":"Mesh","edges":[[0,20,60]],"radius":2}));+ assert!(volume(&mut cold) < 48000.);+ assert!(cold.model.results.iter().all(|r| r.error.is_none()));+}++#[test]+fn failed_mesh_conversions_leave_the_design_unchanged() {+ let mut s = imported_box();+ let before = s.doc.to_json();+ for params in [+ json!({}),+ json!({"body":"Missing"}),+ json!({"body":"Mesh","tolerance":0}),+ json!({"body":"Mesh","tolerance":"unknown"}),+ json!({"body":"Mesh","tolerance":"2 mm"}),+ ] {+ assert!(s.execute("mesh.convert", ¶ms).is_err());+ assert_eq!(s.doc.to_json(), before);+ assert!(s.model.state().body("Mesh").unwrap().body.is_mesh());+ }+}++#[test]+fn exported_binary_stl_with_a_bore_reconstructs_analytic_faces() {+ let mut s = Session::default();+ run(&mut s, "sketch.create", json!({"plane":"XY","name":"Section"}));+ run(&mut s, "sketch.line", json!({"points":[[0,0],[40,0],[40,20],[20,20],[20,30],[0,30]],"closed":true}));+ run(&mut s, "sketch.circle.center", json!({"center":[10,10],"radius":4}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"sketch":"Section","profiles":[{"point":[30,10]}],"distance":15,"body_name":"Bracket"}));+ let path = std::env::temp_dir().join(format!("solvecraft-mesh-convert-{}.stl", std::process::id()));+ run(&mut s, "file.save_mesh", json!({"path":path}));+ run(&mut s, "doc.open", json!({"path":path}));+ let name = s.model.state().bodies[0].name.clone();+ run(&mut s, "mesh.convert", json!({"body":name,"tolerance":"0.05 mm"}));+ let state = s.model.state();+ let body = &state.bodies[0].body;+ assert!(!body.is_mesh());+ assert!(body.validity().is_empty());+ assert_eq!(solvecraft_kernel::measure(body).unwrap().merged.face_types.get("cylinder"), Some(&1));+ assert_eq!(body.faces(0.01).unwrap().len(), 10);+ std::fs::remove_file(path).unwrap();+}diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex 2fbd0dcdf6..5a3b45f6eb 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -35,6 +35,7 @@ mod intersection_curve_tests;mod lip;mod loopblend;mod measure;+mod mesh_convert;mod meshbody;mod offset;mod ops;@@ -69,6 +70,7 @@ pub use iges_in::{MAX_IGES_BYTES, iges_import, iges_to_step};pub use iges_out::iges_export_bodies;pub use lip::raise_band;pub use measure::{BodyMeasure, measure};+pub use mesh_convert::convert_prismatic_mesh;pub use meshbody::{MAX_TRIANGLES, mesh_body};pub use offset::with_same_surface;pub use ops::{BoolOp, boolean, can_join_touching_faces, split_by_plane, transform, transform_matrix};diff --git a/crates/kernel/src/mesh_convert.rs b/crates/kernel/src/mesh_convert.rsnew file mode 100644index 0000000000..5dceb88d10--- /dev/null+++ b/crates/kernel/src/mesh_convert.rs@@ -0,0 +1,471 @@+//! Conservative reconstruction of constant-section mechanical mesh parts.+//! Geometry is inferred from closed, manifold input, never from a display mesh.++use std::collections::BTreeMap;++use solvecraft_geom::{Loop2, Plane, Region2, Vec2, Vec3};++use crate::{Body, KernelError, Result};++const MAX_TRIANGLES: usize = 50_000;+const MAX_BOUNDARY: usize = 8192;++fn invalid(message: &str) -> KernelError {+ KernelError::Invalid(format!("mesh conversion: {message}"))+}++/// Reconstruct a constant-section mesh as analytic planes and, where certified+/// within `tolerance` mm, circular cylinders. The source mesh is not modified.+/// Unsupported shapes are refused instead of silently returning a faceted solid.+pub fn convert_prismatic_mesh(body: &Body, tolerance: f64) -> Result<Body> {+ crate::guard("convert prismatic mesh", || {+ if !tolerance.is_finite() || !(1e-6..=1.).contains(&tolerance) {+ return Err(invalid("tolerance must be between 0.000001 and 1 mm"));+ }+ let input = body.mesh.as_ref().ok_or_else(|| invalid("select a mesh body"))?;+ let welded = weld(input, tolerance)?;+ let mesh = welded.mesh.as_ref().ok_or_else(|| invalid("empty mesh"))?;+ if mesh.triangles.len() > MAX_TRIANGLES {+ return Err(invalid("mesh exceeds the 50000-triangle conversion budget"));+ }+ let mut edges: BTreeMap<(u32, u32), (usize, i32)> = BTreeMap::new();+ let mut axes: BTreeMap<(i64, i64, i64), (Vec3, f64)> = BTreeMap::new();+ for triangle in &mesh.triangles {+ let [a, b, c] = *triangle;+ let (Some(pa), Some(pb), Some(pc)) = (mesh.positions.get(a as usize), mesh.positions.get(b as usize), mesh.positions.get(c as usize))+ else {+ return Err(invalid("triangle refers to a missing vertex"));+ };+ let cross = (*pb - *pa).cross(*pc - *pa);+ let Some(mut n) = cross.normalized() else { return Err(invalid("degenerate triangle")) };+ for (a, b) in [(a, b), (b, c), (c, a)] {+ let entry = edges.entry((a.min(b), a.max(b))).or_default();+ entry.0 += 1;+ entry.1 += if a < b { 1 } else { -1 };+ }+ if n.x < -1e-8 || (n.x.abs() <= 1e-8 && (n.y < -1e-8 || (n.y.abs() <= 1e-8 && n.z < 0.))) {+ n = -n;+ }+ let key = ((n.x * 1e7).round() as i64, (n.y * 1e7).round() as i64, (n.z * 1e7).round() as i64);+ let entry = axes.entry(key).or_insert((n, 0.));+ entry.1 += cross.len();+ }+ if edges.values().any(|&(count, balance)| count != 2 || balance != 0) {+ return Err(invalid("mesh must be closed and consistently oriented, with two triangles per edge"));+ }+ let mut axes: Vec<_> = axes.into_values().collect();+ axes.sort_by(|a, b| b.1.total_cmp(&a.1));+ for (axis, _) in axes.into_iter().take(16) {+ if let Some(result) = extrusion(mesh, axis, tolerance)? {+ return Ok(result);+ }+ }+ Err(invalid("this mesh is not a supported constant-section prism; no geometry was converted"))+ })+}++fn weld(mesh: &crate::meshbody::TriMesh, tolerance: f64) -> Result<Body> {+ if mesh.triangles.len() > MAX_TRIANGLES || mesh.positions.len() > MAX_TRIANGLES * 3 {+ return Err(invalid("mesh exceeds the conversion budget"));+ }+ let bounds = mesh.positions.iter().fold(solvecraft_geom::Aabb3::EMPTY, |mut b, p| {+ b.add(*p);+ b+ });+ let epsilon = (bounds.size().len().max(1.) * 1e-7).min(tolerance * 0.01).max(1e-9);+ if !epsilon.is_finite() || mesh.positions.iter().any(|p| [p.x, p.y, p.z].iter().any(|v| !v.is_finite() || (v / epsilon).abs() > 1e15)) {+ return Err(invalid("mesh coordinates exceed the conversion budget"));+ }+ let key = |p: Vec3| ((p.x / epsilon).floor() as i64, (p.y / epsilon).floor() as i64, (p.z / epsilon).floor() as i64);+ let mut grid = BTreeMap::<_, Vec<u32>>::new();+ let mut positions: Vec<Vec3> = Vec::new();+ let mut remap = Vec::new();+ let mut comparisons = 0usize;+ for &p in &mesh.positions {+ let k = key(p);+ let mut found = None;+ for dx in -1..=1 {+ for dy in -1..=1 {+ for dz in -1..=1 {+ for &i in grid.get(&(k.0 + dx, k.1 + dy, k.2 + dz)).into_iter().flatten() {+ comparisons += 1;+ if comparisons > 8_000_000 {+ return Err(invalid("vertex welding exceeds its work budget"));+ }+ if positions.get(i as usize).is_some_and(|q| q.dist(p) <= epsilon) {+ found = Some(i);+ break;+ }+ }+ }+ }+ }+ let i = match found {+ Some(i) => i,+ None => {+ let i = u32::try_from(positions.len()).map_err(|_| invalid("too many vertices"))?;+ positions.push(p);+ grid.entry(k).or_default().push(i);+ i+ }+ };+ remap.push(i);+ }+ let triangles = mesh+ .triangles+ .iter()+ .map(|t| {+ let (Some(&a), Some(&b), Some(&c)) = (remap.get(t[0] as usize), remap.get(t[1] as usize), remap.get(t[2] as usize)) else {+ return Err(invalid("missing triangle vertex"));+ };+ Ok([a, b, c])+ })+ .collect::<Result<Vec<_>>>()?;+ crate::mesh_body(&positions, &triangles)+}++fn extrusion(mesh: &crate::meshbody::TriMesh, axis: Vec3, tolerance: f64) -> Result<Option<Body>> {+ let (lo, hi) = mesh.positions.iter().map(|p| p.dot(axis)).fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), h| (lo.min(h), hi.max(h)));+ let height = hi - lo;+ let bounds = mesh.positions.iter().fold(solvecraft_geom::Aabb3::EMPTY, |mut b, p| {+ b.add(*p);+ b+ });+ let epsilon = (bounds.size().len().max(1.) * 1e-7).min(tolerance * 0.01).max(1e-9);+ if height <= epsilon {+ return Ok(None);+ }+ let Some(plane) = Plane::from_normal(axis * lo, axis) else { return Ok(None) };+ let mut caps = [BTreeMap::<(u32, u32), usize>::new(), BTreeMap::new()];+ for triangle in &mesh.triangles {+ let [a, b, c] = *triangle;+ let (Some(pa), Some(pb), Some(pc)) = (mesh.positions.get(a as usize), mesh.positions.get(b as usize), mesh.positions.get(c as usize)) else {+ return Err(invalid("missing triangle vertex"));+ };+ let hs = [pa.dot(axis), pb.dot(axis), pc.dot(axis)];+ let cap = if hs.iter().all(|h| (h - lo).abs() <= epsilon) {+ 0+ } else if hs.iter().all(|h| (h - hi).abs() <= epsilon) {+ 1+ } else {+ // STL stores coordinates as f32. Test the projected triangle's+ // distance from a line rather than amplifying that rounding into+ // an angular error on narrow side triangles.+ let [a, b, c] = [plane.to_local(*pa), plane.to_local(*pb), plane.to_local(*pc)];+ let length = a.dist(b).max(b.dist(c)).max(c.dist(a));+ if (b - a).cross(c - a).abs() > epsilon * 3. * length {+ return Ok(None);+ }+ continue;+ };+ let Some(edges) = caps.get_mut(cap) else { return Ok(None) };+ for (a, b) in [(a, b), (b, c), (c, a)] {+ *edges.entry((a.min(b), a.max(b))).or_default() += 1;+ }+ }+ let raw_key = |p: Vec2| ((p.x / epsilon).floor() as i64, (p.y / epsilon).floor() as i64);+ let mut positions = BTreeMap::<(i64, i64), Vec2>::new();+ let mut projected = Vec::with_capacity(mesh.positions.len());+ for p in &mesh.positions {+ let p = plane.to_local(*p);+ let k = raw_key(p);+ let mut canonical = None;+ for dx in -1..=1 {+ for dy in -1..=1 {+ let candidate = (k.0 + dx, k.1 + dy);+ if positions.get(&candidate).is_some_and(|q| q.dist(p) <= epsilon) {+ canonical = Some(candidate);+ }+ }+ }+ let canonical = canonical.unwrap_or(k);+ positions.entry(canonical).or_insert(p);+ projected.push(canonical);+ }+ let boundary = |cap: usize| -> Option<BTreeMap<(i64, i64), Vec<(i64, i64)>>> {+ let mut adjacency = BTreeMap::<_, Vec<_>>::new();+ for (&(a, b), &count) in caps.get(cap)? {+ if count == 2 {+ continue;+ }+ if count != 1 {+ return None;+ }+ let (a, b) = (*projected.get(a as usize)?, *projected.get(b as usize)?);+ if a == b {+ return None;+ }+ adjacency.entry(a).or_default().push(b);+ adjacency.entry(b).or_default().push(a);+ }+ for neighbours in adjacency.values_mut() {+ neighbours.sort();+ }+ Some(adjacency)+ };+ let (Some(mut adjacency), Some(other)) = (boundary(0), boundary(1)) else { return Ok(None) };+ if adjacency != other || adjacency.is_empty() || adjacency.len() > MAX_BOUNDARY || adjacency.values().any(|n| n.len() != 2) {+ return Ok(None);+ }+ // Every side vertex must lie on an unchanged straight extrusion of the cap.+ // This excludes twisted, tapered and stepped meshes before fitting any circles.+ let point = |k: (i64, i64)| Vec2::new(k.0 as f64 * epsilon, k.1 as f64 * epsilon);+ let boundary_segments: Vec<_> =+ adjacency.iter().flat_map(|(&a, bs)| bs.iter().filter(move |&&b| a < b).map(move |&b| (point(a), point(b)))).collect();+ if mesh.positions.len().saturating_mul(boundary_segments.len()) > 32_000_000 {+ return Err(invalid("boundary certification exceeds its work budget"));+ }+ for p in &mesh.positions {+ let h = p.dot(axis);+ if (h - lo).abs() <= epsilon || (h - hi).abs() <= epsilon {+ continue;+ }+ let p = plane.to_local(*p);+ if !boundary_segments.iter().any(|&(a, b)| {+ solvecraft_geom::Seg2::Line { a, b }.point_at(solvecraft_geom::Seg2::Line { a, b }.closest_param(p)).dist(p) <= epsilon * 3.+ }) {+ return Ok(None);+ }+ }+ let mut loops = Vec::new();+ let mut raw_loops = Vec::new();+ while let Some((&start, _)) = adjacency.first_key_value() {+ let mut current = start;+ let mut previous = None;+ let mut chain = Vec::new();+ for _ in 0..=MAX_BOUNDARY {+ let Some(neighbours) = adjacency.remove(¤t) else { return Ok(None) };+ chain.push(*positions.get(¤t).unwrap_or(&point(current)));+ let next = neighbours.into_iter().find(|n| Some(*n) != previous);+ let Some(next) = next else { return Ok(None) };+ if next == start {+ break;+ }+ previous = Some(current);+ current = next;+ }+ if chain.len() < 3 || current == start {+ return Ok(None);+ }+ raw_loops.push(Loop2::polygon(&chain));+ loops.push(fit_loop(&chain, tolerance, epsilon));+ }+ certify_nesting(&raw_loops, &loops, epsilon, bounds.size().len())?;+ // Nest by the original polygon, so smoothing cannot change which loop is a hole.+ let mut regions: Vec<Region2> = Vec::new();+ for (i, lp) in loops.iter().enumerate() {+ let Some(probe) = raw_loops.get(i).and_then(|l| l.segs.first()).map(|s| s.start()) else { return Ok(None) };+ let owners: Vec<_> = raw_loops.iter().enumerate().filter(|(j, other)| *j != i && other.contains(probe)).collect();+ if owners.len() % 2 == 0 {+ regions.push(Region2 { outer: lp.ccw(), holes: Vec::new() });+ }+ }+ for (i, lp) in loops.iter().enumerate() {+ let Some(probe) = raw_loops.get(i).and_then(|l| l.segs.first()).map(|s| s.start()) else { return Ok(None) };+ let owners = raw_loops.iter().enumerate().filter(|(j, other)| *j != i && other.contains(probe)).count();+ if owners % 2 == 1 {+ let owner = regions+ .iter()+ .enumerate()+ .filter(|(_, r)| r.outer.contains(probe))+ .min_by(|(_, a), (_, b)| a.outer.signed_area().abs().total_cmp(&b.outer.signed_area().abs()))+ .map(|(i, _)| i);+ let Some(region) = owner.and_then(|i| regions.get_mut(i)) else { return Ok(None) };+ region.holes.push(lp.ccw().reversed());+ }+ }+ let body = crate::extrude_planar_regions(&plane, ®ions, 0., height)?;+ if !body.validity().is_empty() {+ return Err(invalid("reconstructed solid did not pass validity checks"));+ }+ let perimeter: f64 = loops.iter().flat_map(|lp| &lp.segs).map(|s| s.length()).sum();+ let original = mesh.to_mesh().measure().volume;+ let rebuilt = crate::measure(&body)?.volume;+ if !original.is_finite() || original <= 0. || (rebuilt - original).abs() > perimeter * height * tolerance + epsilon * bounds.size().len().powi(2)+ {+ return Err(invalid("reconstructed volume is inconsistent with the source mesh"));+ }+ Ok(Some(body))+}++fn certify_nesting(raw: &[Loop2], fitted: &[Loop2], epsilon: f64, size: f64) -> Result<()> {+ let mut work = 0usize;+ for (i, a) in raw.iter().enumerate() {+ for (j, b) in raw.iter().enumerate().skip(i + 1) {+ work = work.saturating_add(a.segs.len().saturating_mul(b.segs.len()));+ if work > 16_000_000 {+ return Err(invalid("loop certification exceeds its work budget"));+ }+ let contains = |a: &Loop2, b: &Loop2| b.segs.first().is_some_and(|s| a.contains(s.start()));+ let (ab, ba) = (contains(a, b), contains(b, a));+ if ab && ba {+ return Err(invalid("overlapping boundary loops"));+ }+ for (a, b) in+ [(a, b), (fitted.get(i).ok_or_else(|| invalid("missing fitted loop"))?, fitted.get(j).ok_or_else(|| invalid("missing fitted loop"))?)]+ {+ let region = |l: &Loop2| Region2 { outer: l.ccw(), holes: Vec::new() };+ let overlap = crate::planar_regions_boolean(&[region(a)], &[region(b)], crate::BoolOp::Intersect, epsilon.clamp(1e-9, 1.))?;+ let area: f64 = overlap.iter().map(Region2::area).sum();+ let expected = if ab {+ b.signed_area().abs()+ } else if ba {+ a.signed_area().abs()+ } else {+ 0.+ };+ if (area - expected).abs() > epsilon * size.max(1.) * 10. {+ return Err(invalid("conversion would cross or merge boundary loops"));+ }+ }+ }+ }+ Ok(())+}++fn fit_loop(points: &[Vec2], tolerance: f64, epsilon: f64) -> Loop2 {+ // Fit a complete circular boundary only with enough samples to distinguish it+ // from a polygon. Certify the chord deviation, not just the vertex residual.+ if points.len() >= 12 {+ let (Some(&a), Some(&b), Some(&c)) = (points.first(), points.get(points.len() / 3), points.get(2 * points.len() / 3)) else {+ return Loop2::polygon(points);+ };+ let u = b - a;+ let v = c - a;+ let d = 2. * u.cross(v);+ if d.abs() > epsilon * epsilon {+ let center = a + Vec2::new(v.y * u.len2() - u.y * v.len2(), u.x * v.len2() - v.x * u.len2()) / d;+ let radius = center.dist(a);+ if radius.is_finite() && radius > epsilon && points.iter().all(|p| (center.dist(*p) - radius).abs() <= epsilon * 3.) {+ let mut sweep = 0.;+ let mut direction = 0f64;+ let valid = (0..points.len()).all(|i| {+ let (Some(a), Some(b)) = (points.get(i), points.get((i + 1) % points.len())) else { return false };+ let signed = ((*a - center).cross(*b - center)).atan2((*a - center).dot(*b - center));+ if direction == 0. {+ direction = signed.signum();+ }+ if signed * direction <= 0. {+ return false;+ }+ sweep += signed;+ let angle = signed.abs();+ angle <= std::f64::consts::PI / 6. + 1e-8 && radius * (1. - (angle * 0.5).cos()) + epsilon * 10. <= tolerance+ });+ if valid && (sweep.abs() - std::f64::consts::TAU).abs() <= 1e-7 {+ return Loop2::circle(center, radius);+ }+ }+ }+ }+ let mut points = points.to_vec();+ let linear_tolerance = epsilon / points.len().max(1) as f64;+ loop {+ let n = points.len();+ if n <= 3 {+ break;+ }+ let remove = (0..n).find(|&i| {+ let (Some(a), Some(b), Some(c)) = (points.get((i + n - 1) % n), points.get(i), points.get((i + 1) % n)) else { return false };+ let edge = solvecraft_geom::Seg2::Line { a: *a, b: *c };+ edge.point_at(edge.closest_param(*b)).dist(*b) <= linear_tolerance+ });+ let Some(index) = remove else { break };+ points.remove(index);+ }+ Loop2::polygon(&points)+}++#[cfg(test)]+mod tests {+ use super::*;++ fn mesh_of(body: &Body) -> Body {+ let mesh = body.tessellate(0.005).unwrap();+ crate::mesh_body(&mesh.positions, &mesh.triangles).unwrap()+ }++ #[test]+ fn reconstructs_planes_holes_and_round_walls_in_arbitrary_orientation() {+ let region = Region2 {+ outer: Loop2::polygon(&[+ Vec2::new(0., 0.),+ Vec2::new(40., 0.),+ Vec2::new(40., 20.),+ Vec2::new(20., 20.),+ Vec2::new(20., 30.),+ Vec2::new(0., 30.),+ ]),+ holes: vec![Loop2::circle(Vec2::new(10., 10.), 4.).reversed()],+ };+ let source = crate::extrude_planar_regions(&Plane::XY, &[region], 0., 15.).unwrap();+ let source = crate::transform(&source, Vec3::new(31., -17., 9.), Vec3::ZERO, Vec3::new(1., 2., 3.), 0.73).unwrap();+ let converted = convert_prismatic_mesh(&mesh_of(&source), 0.05).unwrap();+ assert!(!converted.is_mesh());+ assert!(converted.validity().is_empty());+ let expected = (1000. - std::f64::consts::PI * 16.) * 15.;+ let fine_volume = |body: &Body| body.tessellate_with(1e-5, true).unwrap().measure().volume;+ assert!((fine_volume(&converted) - expected).abs() < 0.02);+ assert!((crate::measure(&converted).unwrap().volume - crate::measure(&source).unwrap().volume).abs() < 1e-7);+ assert_eq!(crate::measure(&converted).unwrap().merged.face_types.get("cylinder"), Some(&1));+ assert!(converted.faces(0.01).unwrap().len() < 15);+ let step = crate::step_export(&[&converted], "SolidCraft regression").unwrap();+ let reopened = crate::step_import(&step).unwrap();+ assert!((fine_volume(&reopened.bodies[0].body) - expected).abs() < 0.02);+ }++ #[test]+ fn planar_boxes_are_exact_and_coarse_polygons_are_not_rounded() {+ let source = crate::box_solid(Vec3::ZERO, Vec3::new(10., 20., 30.)).unwrap();+ let result = convert_prismatic_mesh(&mesh_of(&source), 0.01).unwrap();+ assert_eq!(result.faces(0.01).unwrap().len(), 6);+ assert!((crate::measure(&result).unwrap().volume - 6000.).abs() < 1e-6);+ let points: Vec<_> = (0..6)+ .map(|i| {+ let angle = i as f64 * std::f64::consts::TAU / 6.;+ Vec2::new(angle.cos(), angle.sin()) * 10.+ })+ .collect();+ assert_eq!(fit_loop(&points, 1., 1e-6).segs.len(), 6);+ let points: Vec<_> = (0..16)+ .map(|i| {+ let angle = i as f64 * std::f64::consts::TAU / 16.;+ Vec2::new(angle.cos(), angle.sin()) * 10.+ })+ .collect();+ assert_eq!(fit_loop(&points, 0.001, 1e-6).segs.len(), 16);+ assert_eq!(fit_loop(&points, 0.2, 1e-6).segs.len(), 2);+ }++ #[test]+ fn refuses_open_nonprismatic_and_hostile_inputs() {+ let open = crate::mesh_body(&[Vec3::ZERO, Vec3::X, Vec3::Y], &[[0, 1, 2]]).unwrap();+ assert!(convert_prismatic_mesh(&open, 0.05).is_err());+ let solid = crate::box_solid(Vec3::ZERO, Vec3::new(10., 10., 10.)).unwrap();+ assert!(convert_prismatic_mesh(&solid, 0.05).is_err());+ for tolerance in [f64::NAN, f64::INFINITY, -1., 0., 2.] {+ assert!(convert_prismatic_mesh(&mesh_of(&solid), tolerance).is_err());+ }+ let sphere = crate::sphere(Vec3::ZERO, 10.).unwrap();+ assert!(convert_prismatic_mesh(&mesh_of(&sphere), 0.05).is_err());+ for coordinate in [f64::NAN, f64::INFINITY, f64::MAX, 1e30] {+ let mesh = crate::meshbody::TriMesh { positions: vec![Vec3::new(coordinate, 0., 0.)], triangles: vec![] };+ assert!(weld(&mesh, 0.05).is_err());+ }+ }++ #[test]+ fn fitting_cannot_open_a_hole_through_a_nearby_wall() {+ let outer = Loop2::polygon(&[Vec2::new(-1., -1.), Vec2::new(1., -1.), Vec2::new(1., 1.), Vec2::new(-1., 1.)]);+ let points: Vec<_> = (0..12)+ .map(|i| {+ let angle = (i as f64 + 0.5) * std::f64::consts::TAU / 12.;+ Vec2::new(angle.cos(), angle.sin()) * 1.02+ })+ .collect();+ let inner = Loop2::polygon(&points);+ let fitted = fit_loop(&points, 0.05, 1e-6);+ assert_eq!(fitted.segs.len(), 2);+ assert!(certify_nesting(&[outer.clone(), inner], &[outer, fitted], 1e-6, 3.).is_err());+ }+}diff --git a/crates/ui-egui/src/dialogs_surface.rs b/crates/ui-egui/src/dialogs_surface.rsindex da832ef35e..cfbf7bf135 100644--- a/crates/ui-egui/src/dialogs_surface.rs+++ b/crates/ui-egui/src/dialogs_surface.rs@@ -16,6 +16,7 @@ use crate::selection::{BODIES, EDGES, FACES, PLANES, PROFILES, SelInput};pub enum Surf {Patch,Stitch { tolerance: String },+ ConvertMesh { tolerance: String },Thicken { thickness: String, symmetric: bool, operation: usize },Extend { distance: String },Trim,@@ -27,6 +28,7 @@ impl Surf {match self {Surf::Patch => "PATCH",Surf::Stitch { .. } => "STITCH",+ Surf::ConvertMesh { .. } => "CONVERT MESH",Surf::Thicken { .. } => "THICKEN",Surf::Extend { .. } => "EXTEND",Surf::Trim => "TRIM",@@ -48,6 +50,7 @@ fn inputs(k: &Surf) -> Vec<SelInput> {match k {Surf::Patch => vec![SelInput::new("Boundary", PROFILES | EDGES, true)],Surf::Stitch { .. } => vec![SelInput::new("Surfaces", BODIES, true)],+ Surf::ConvertMesh { .. } => vec![SelInput::new("Mesh body", BODIES, false)],Surf::Thicken { .. } => vec![SelInput::new("Surfaces", BODIES, true)],Surf::Extend { .. } => vec![SelInput::new("Edges", EDGES, true)],Surf::Trim => vec![@@ -64,6 +67,7 @@ pub fn start(_app: &SolveApp, id: &str) -> Option<(Kind, Vec<SelInput>)> {let k = match id {"surface.patch" => Surf::Patch,"surface.stitch" => Surf::Stitch { tolerance: String::new() },+ "mesh.convert" => Surf::ConvertMesh { tolerance: "0.05 mm".into() },"surface.thicken" => Surf::Thicken { thickness: "2 mm".into(), symmetric: false, operation: 0 },"surface.extend" => Surf::Extend { distance: "10 mm".into() },"surface.trim" => Surf::Trim,@@ -78,7 +82,7 @@ pub fn start(_app: &SolveApp, id: &str) -> Option<(Kind, Vec<SelInput>)> {pub fn rows(ui: &mut egui::Ui, k: &mut Surf) -> bool {let mut enter = false;match k {- Surf::Stitch { tolerance } => {+ Surf::Stitch { tolerance } | Surf::ConvertMesh { tolerance } => {row_label(ui, "Tolerance");let r = ui.add(egui::TextEdit::singleline(tolerance).hint_text("tight"));crate::params_dialog::complete(ui, &r, tolerance);@@ -159,6 +163,11 @@ pub fn commands(app: &SolveApp, k: &Surf, inputs: &[SelInput], extra: &Map<Strin}("surface.stitch", p)}+ Surf::ConvertMesh { tolerance } => {+ need(0, "a closed mesh body")?;+ let body = bodies(inputs, 0).into_iter().next().ok_or("select a mesh body")?;+ ("mesh.convert", json!({"body":body,"tolerance":tolerance}))+ }Surf::Thicken { thickness, symmetric, operation } => {need(0, "the surfaces to thicken")?;(@@ -235,6 +244,9 @@ pub fn for_feature(app: &SolveApp, kind: &FeatureKind) -> Option<(Kind, Vec<SelISurf::Stitch { tolerance: if tolerance.trim() == "0" { String::new() } else { tolerance.clone() } },vec![bodies.iter().map(|n| Sel::Body { name: n.clone() }).collect()],),+ FeatureKind::MeshConvert { body, tolerance } => {+ (Surf::ConvertMesh { tolerance: tolerance.clone() }, vec![vec![Sel::Body { name: body.clone() }]])+ }FeatureKind::Thicken { bodies, thickness, symmetric, operation, .. } => (Surf::Thicken { thickness: thickness.clone(), symmetric: *symmetric, operation: op_index(operation) },vec![bodies.iter().map(|n| Sel::Body { name: n.clone() }).collect()],diff --git a/crates/ui-egui/src/timeline.rs b/crates/ui-egui/src/timeline.rsindex fe53568a99..59e95a5529 100644--- a/crates/ui-egui/src/timeline.rs+++ b/crates/ui-egui/src/timeline.rs@@ -32,7 +32,7 @@ fn icon_of(k: &FeatureKind) -> &'static str {FeatureKind::Draft { .. } => "draft",FeatureKind::Split { .. } => "split",FeatureKind::Move { .. } => "move",- FeatureKind::Import { .. } | FeatureKind::MeshImport { .. } => "import",+ FeatureKind::Import { .. } | FeatureKind::MeshImport { .. } | FeatureKind::MeshConvert { .. } => "import",other => crate::workspace::feature_icon(other).unwrap_or("feature"),}}diff --git a/crates/ui-egui/tests/mesh_conversion.rs b/crates/ui-egui/tests/mesh_conversion.rsnew file mode 100644index 0000000000..5ca95ff9ad--- /dev/null+++ b/crates/ui-egui/tests/mesh_conversion.rs@@ -0,0 +1,44 @@+use serde_json::json;+use solvecraft_engine::doc::{Document, FeatureKind, MeshData};+use solvecraft_engine::geom::Vec3;+use solvecraft_engine::{Sel, Session};+use solvecraft_ui_egui::scenario::Harness;++#[test]+fn convert_mesh_uses_preselection_and_reopens_its_timeline_dialog() {+ let body = solvecraft_engine::kernel::box_solid(Vec3::ZERO, Vec3::new(10., 20., 30.)).unwrap();+ let mesh = body.tessellate(0.01).unwrap();+ let mut doc = Document::default();+ doc.add_feature(+ FeatureKind::MeshImport {+ file: "box.stl".into(),+ meshes: vec![MeshData {+ name: "Mesh".into(),+ positions: mesh.positions.iter().flat_map(|p| [p.x, p.y, p.z]).collect(),+ triangles: mesh.triangles.iter().flatten().copied().collect(),+ color: None,+ }],+ },+ None,+ )+ .unwrap();+ let mut h = Harness::new();+ h.app.session = Session::new(doc);+ h.app.session.selection = vec![Sel::Body { name: "Mesh".into() }];+ h.step(&json!({"start":"mesh.convert"})).unwrap();+ let dialog = h.app.dialog.as_ref().unwrap();+ assert_eq!(dialog.inputs[0].items, vec![Sel::Body { name: "Mesh".into() }]);+ h.step(&json!({"widget":"OK"})).unwrap();+ assert!(h.app.dialog.is_none(), "{:?}", h.app.status);+ assert!(!h.app.session.model.state().body("Mesh").unwrap().body.is_mesh());+ let feature = h.app.session.doc.features.last().unwrap().id;+ let response = h.call("ui.editFeature", json!({"feature":feature}));+ assert_eq!(response["ok"], true, "{response}");+ let dialog = h.app.dialog.as_ref().unwrap();+ assert!(+ matches!(&dialog.kind,solvecraft_ui_egui::dialogs::Kind::Surface(solvecraft_ui_egui::dialogs_surface::Surf::ConvertMesh { tolerance }) if tolerance=="0.05 mm")+ );+ assert!(h.app.session.model.state().body("Mesh").unwrap().body.is_mesh());+ h.step(&json!({"key":"Escape"})).unwrap();+ assert!(!h.app.session.model.state().body("Mesh").unwrap().body.is_mesh());+}diff --git a/docs/book/src/guide/files.md b/docs/book/src/guide/files.mdindex e236ae57de..de42425d53 100644--- a/docs/book/src/guide/files.md+++ b/docs/book/src/guide/files.md@@ -13,6 +13,20 @@ Opening a STEP or IGES file creates a design with the file's bodies as a base feinserting one adds them to the current design. Later features build on them. Mesh bodies render,measure, move and export, but solid features need B-rep bodies.+For closed mechanical meshes with a constant cross-section, use **Mesh → Modify →+Convert Mesh**. Select the mesh body and set the fitting tolerance. The conversion+rebuilds planar faces and circular through-walls, replacing the mesh with a solid+that accepts solid modeling operations. The imported triangles remain embedded+upstream: changing their scale, undoing the conversion or reopening the design+rebuilds the result through the timeline. Double-click the conversion to edit its+tolerance or source body.++The tolerance bounds circular reconstruction against the original chords. Coarse+polygons remain polygons when rounding would exceed it. Open/nonmanifold meshes,+tapers, stepped parts and organic scans are refused by this first reconstruction+method; it does not silently substitute a faceted solid. Conversion currently+accepts at most 50,000 triangles and a bounded number of boundary segments.+Saves are atomic: a crash at any moment leaves either the old file or the new one, and thereplaced version is kept as `<file>.bak`. Unsaved changes are autosaved to a recovery folder,and the next launch offers to recover them. Older design files are upgraded on open, and filesdiff --git a/docs/parity.md b/docs/parity.mdindex ed9c52e97a..5fcbd494ee 100644--- a/docs/parity.md+++ b/docs/parity.md@@ -2,9 +2,9 @@Generated by `cargo xtask parity` from `xtask/data/fusion-catalog.tsv` (the toolbar commands of Fusion's Design workspace, ids and names only) and the live command registry (`solvecraft-cli commands`). A command counts as live when SolidCraft registers the same command id. This measures breadth, not depth; see ROADMAP.md and docs/oracle.md for depth.-**In scope (SOLID, SKETCH, ASSEMBLY, SHEET METAL, PLASTIC enclosure subset): 335 / 541 commands live (62%).** SOLID + SKETCH: 188 / 291 (65%). Registered commands: 311.+**In scope (SOLID, SKETCH, ASSEMBLY, SHEET METAL, PLASTIC enclosure subset): 335 / 541 commands live (62%).** SOLID + SKETCH: 188 / 291 (65%). Registered commands: 314.-Deferred until further notice (not in the in-scope figure): MESH, FORM, SURFACE beyond what solids need, PCB, render, animation, simulation, manufacture, drawings, MANAGE, UTILITIES and the rest of PLASTIC. All Design tabs together: 630 / 1175 (54%).+Deferred until further notice (not in the in-scope figure): MESH, FORM, SURFACE beyond what solids need, PCB, render, animation, simulation, manufacture, drawings, MANAGE, UTILITIES and the rest of PLASTIC. All Design tabs together: 631 / 1175 (54%).| Tab | Panel | Live | Total | % ||---|---|---:|---:|---:|@@ -64,7 +64,7 @@ Deferred until further notice (not in the in-scope figure): MESH, FORM, SURFACE| SURFACE | POSITION | 2 | 2 | 100% || MESH | CREATE | 2 | 5 | 40% || MESH | PREPARE | 0 | 4 | 0% |-| MESH | MODIFY | 6 | 30 | 20% |+| MESH | MODIFY | 7 | 30 | 23% || MESH | ASSEMBLE | 12 | 21 | 57% || MESH | CONFIGURE | 3 | 3 | 100% || MESH | CONSTRUCT | 19 | 20 | 95% |diff --git a/xtask/data/fusion-ids.tsv b/xtask/data/fusion-ids.tsvindex e61809ad8f..965acc4478 100644--- a/xtask/data/fusion-ids.tsv+++ b/xtask/data/fusion-ids.tsv@@ -181,3 +181,4 @@ FusionSnapFitCommand plastic.snap_fitFusionLipCommand plastic.lipFusionRestCommand plastic.restConstructionPlanePerpendicularToPlaneCommand construct.plane.perpendicular+ParaMeshConvertCommand mesh.convert