SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Thread: turn a shaft thicker than a modelled thread down to its major diameter (#4256)
bherbruck971b22324669
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 29ec73ce28..f673c785f4 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -324,11 +324,12 @@ fn format_thread(d: f64, p: f64) -> String {/// The automatic ISO metric designation for a cylindrical face, using the same fit check as/// a thread feature without an explicit size. This query does not change the model.pub fn suggested_thread(st: &ModelState, p: Vec3) -> Result<String> {- thread_on(st, 0, p, None, None).map(|t| t.designation)+ thread_on(st, 0, p, None, None, false).map(|t| t.designation)}-/// A cosmetic thread on the cylindrical face at `p`.-fn thread_on(st: &ModelState, feature: u64, p: Vec3, designation: Option<&str>, length: Option<f64>) -> Result<ThreadInfo> {+/// A cosmetic thread on the cylindrical face at `p`. A `turned` (modelled) thread also fits a+/// shaft thicker than it, which it turns down to its major diameter first.+fn thread_on(st: &ModelState, feature: u64, p: Vec3, designation: Option<&str>, length: Option<f64>, turned: bool) -> Result<ThreadInfo> {let (body, cyl) = st.bodies.iter()@@ -346,7 +347,7 @@ fn thread_on(st: &ModelState, feature: u64, p: Vec3, designation: Option<&str>,let fits = if cyl.internal {(major - pitch * 1.0825 - dia).abs() < 0.2 * major || (major - pitch - dia).abs() < 0.15 * major} else {- (major - dia).abs() < 0.15 * major+ (major - dia).abs() < 0.15 * major || (turned && dia > major)};if !fits {return Err(DocError::Invalid(format!(@@ -468,6 +469,73 @@ fn thread_groove(t: &ThreadInfo, radius: f64, open: (bool, bool)) -> Result<soliOk(kernel::sweep_helix_mesh(&plane, §ion, base, *k, p, (s1 - s0) / p, stations as usize)?)}+/// What a modelled external thread turns off a shaft thicker than its major diameter before it+/// cuts, as a lathe would: the ring between the major diameter and the shaft over the threaded+/// length, run on past an end of the face that nothing of the part (`mb`) lies beyond. `None`+/// for a shaft no thicker than the thread. Its inner wall is the turned face, named `turned`;+/// an end that stops inside the face leaves a shoulder, `shoulder:start` or `shoulder:end`.+fn thread_turn(t: &ThreadInfo, cyl: &kernel::CylinderFace, mb: &ModelBody) -> Result<Option<Traced>> {+ let (p, r) = (t.pitch, t.major_diameter / 2.0);+ if t.internal || !(cyl.radius > r * (1.0 + 1e-6)) {+ return Ok(None);+ }+ let k = t.axis;+ let u = k.cross(if k.x.abs() < 0.9 { Vec3::new(1.0, 0.0, 0.0) } else { Vec3::new(0.0, 1.0, 0.0) });+ let u = u.normalized().ok_or_else(|| DocError::Invalid("thread axis".into()))?;+ let v = k.cross(u);+ let mesh = mb.mesh();+ let solid_round = |s: f64, radius: f64| {+ (0..12).any(|i| {+ let a = std::f64::consts::TAU * f64::from(i) / 12.0;+ mesh.contains(t.axis_point + *k * s + (u * a.cos() + v * a.sin()) * radius)+ })+ };+ // The ring reaches a little past the shaft; the part must not go on there (a shaft standing+ // in a corner, a rounded edge), or the turning would cut into it.+ let out = cyl.radius + 0.1 * p;+ if [0.25, 0.5, 0.75].iter().any(|f| solid_round(t.start + (t.end - t.start) * f, cyl.radius + 0.05 * p)) {+ return Err(DocError::Invalid(format!(+ "this {} mm shaft is too thick for a modelled {} thread, and the part around it keeps it from being turned down; make the shaft {} mm",+ show_mm(2.0 * cyl.radius),+ t.designation,+ show_mm(t.major_diameter)+ )));+ }+ // Past a free end of the face out into the air; elsewhere square at the threaded length's end.+ let tol = p * 1e-3;+ let mid = (r + cyl.radius) / 2.0;+ let free = |at: f64, s: f64, past: f64| (at - s).abs() < tol && !solid_round(s + past * 0.5 * p, mid);+ let (open0, open1) = (free(cyl.start, t.start, -1.0), free(cyl.end, t.end, 1.0));+ let s0 = if open0 { t.start - p } else { t.start };+ let s1 = if open1 { t.end + p } else { t.end };+ let plane = Plane { origin: t.axis_point, x: u, y: *k };+ let ring = [Vec2::new(r, s0), Vec2::new(out, s0), Vec2::new(out, s1), Vec2::new(r, s1)];+ let region = Region2 { outer: solidcraft_geom::Loop2::polygon(&ring), holes: vec![] };+ let ring = kernel::revolve(&plane, &[region], Vec2::ZERO, Vec2::Y, std::f64::consts::TAU)?+ .into_iter()+ .next()+ .ok_or_else(|| DocError::Invalid("thread: the shaft turned down to the thread".into()))?;+ // The ring's sides by profile segment: its start end, outside, end end, inner wall.+ let role = |segment: usize| -> Vec<String> {+ match segment {+ 0 if !open0 => vec!["shoulder:start".into()],+ 2 if !open1 => vec!["shoulder:end".into()],+ 3 => vec!["turned".into()],+ _ => Vec::new(),+ }+ };+ let roles = ring.history().filter(|h| h.operands == 0).map(|h| {+ h.faces+ .iter()+ .map(|f| match f.origins.as_slice() {+ [kernel::history::FaceOrigin::Profile { segment }] => role(*segment),+ _ => Vec::new(),+ })+ .collect()+ });+ Ok(Some(Traced::made(ring, roles)))+}+/// A constant fillet of `edges`; with [`FilletFit::Reduce`](crate::FilletFit::Reduce), a radius too/// large for the geometry around them is reduced where it doesn't fit, to the largest that works/// for each group of edges sharing a face; the radius per edge is returned. With@@ -5428,7 +5496,7 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:let r = val(vals, diameter, Kind::Length)? / 2.0;for p in spots {let wall = p + dir.any_perp() * r + dir * (r * 0.5);- let t = thread_on(st, f.id, wall, Some(d), None)?;+ let t = thread_on(st, f.id, wall, Some(d), None, false)?;st.threads.push(t);}}@@ -5439,7 +5507,7 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:Some(e) => Some(val(vals, e, Kind::Length)?),None => None,};- let t = thread_on(st, f.id, face.0, designation.as_deref(), l)?;+ let t = thread_on(st, f.id, face.0, designation.as_deref(), l, *modeled)?;if !*modeled {st.threads.push(t);return Ok(());@@ -5448,14 +5516,24 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:let Some(mb) = st.bodies.get(i).cloned() else { return Err(DocError::Invalid("body".into())) };let cyl = kernel::cylinder_face_at(&mb.body, face.0).ok_or_else(|| DocError::Invalid("no cylindrical face there to thread".into()))?;let tol = t.pitch * 1e-3;- let groove = thread_groove(&t, cyl.radius, ((t.start - cyl.start).abs() < tol, (t.end - cyl.end).abs() < tol))?;+ // A shaft thicker than the thread is turned down to its major diameter first.+ let input = mb.traced();+ let (input, radius) = match thread_turn(&t, &cyl, &mb)? {+ Some(ring) => {+ let turned = kernel::boolean(&input.body, &ring.body, BoolOp::Cut)?+ .ok_or_else(|| DocError::Invalid("turning the shaft down removed everything".into()))?;+ (Traced::step(turned, &[&input, &ring]), t.major_diameter / 2.0)+ }+ None => (input, cyl.radius),+ };+ let groove = thread_groove(&t, radius, ((t.start - cyl.start).abs() < tol, (t.end - cyl.end).abs() < tol))?;// The B-rep boolean can't take helical walls in reasonable time: the body is cut// faceted (curved faces within a two-hundredth of the pitch).- let nb = kernel::faceted_boolean(&mb.body, &groove, BoolOp::Cut, t.pitch * 0.005)?+ let nb = kernel::faceted_boolean(&input.body, &groove, BoolOp::Cut, t.pitch * 0.005)?.ok_or_else(|| DocError::Invalid("the thread removed everything".into()))?;// The groove's faces are its triangles, with no role to name them by.let groove = crate::lineage::Lineage::unnamed_faces(groove.triangles.len());- let lineage = mb.traced().lineage.and_then(|l| crate::lineage::Lineage::step(&nb, &[&l, &groove]));+ let lineage = input.lineage.and_then(|l| crate::lineage::Lineage::step(&nb, &[&l, &groove]));let nb = Traced { body: nb, lineage };if let Some(slot) = st.bodies.get_mut(i) {*slot = ModelBody::traced_new(mb.name, nb, mb.feature);diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rsindex 9c26734ad9..6664de7892 100644--- a/crates/engine/src/cmd/features.rs+++ b/crates/engine/src/cmd/features.rs@@ -92,7 +92,7 @@ pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("solid.thread", "Thread", thread).at("SOLID", "CREATE").icon("thread")- .params("face: [x,y,z] on a cylindrical face; designation?: ISO metric (\"M8\", \"M8x1\"; default: the size that fits); length?: expr (default: the whole face); modeled?: bool (default false). Cosmetic: the model is unchanged, model.threads lists it. Modeled: cuts the thread profile into the body"),+ .params("face: [x,y,z] on a cylindrical face; designation?: ISO metric (\"M8\", \"M8x1\"; default: the size that fits); length?: expr (default: the whole face); modeled?: bool (default false). Cosmetic: the model is unchanged, model.threads lists it. Modeled: cuts the thread profile into the body; a shaft thicker than the thread is first turned down to its major diameter over the threaded length"),CommandSpec::new("solid.shell", "Shell", shell).at("SOLID", "MODIFY").icon("shell")diff --git a/crates/engine/src/thread_tests.rs b/crates/engine/src/thread_tests.rsindex 5f12c78fc0..7778a3a818 100644--- a/crates/engine/src/thread_tests.rs+++ b/crates/engine/src/thread_tests.rs@@ -4,6 +4,7 @@use std::f64::consts::PI;use serde_json::{Value, json};+use solidcraft_geom::Vec3;use crate::Session;@@ -92,6 +93,89 @@ fn modelled_full_length_fine_threads_on_large_shafts() {}}+/// A modelled thread on a shaft thicker than it turns the shaft down to the major diameter+/// over the threaded length, then cuts the thread: an M6 over the top 8 mm of an 8 mm shaft+/// leaves a 6 mm threaded section on an 8 mm stub, its turned face named for later features.+/// A shaft of the thread's own size is cut as it is.+#[test]+fn a_shaft_thicker_than_a_modelled_thread_is_turned_down_to_it() {+ let (p, len) = (1.0, 8.0);+ let root = 3.0 - 5.0 * p * 3f64.sqrt() / 16.0;+ let groove = per_turn(root, 3.0, |r| p / 4.0 + 2.0 * (r - root) * (PI / 6.0).tan()) * len / p;+ for (shaft, turned) in [(8.0, true), (6.0, false)] {+ let mut s = Session::default();+ run(&mut s, "solid.cylinder", json!({"radius": shaft / 2.0, "height": 12, "body_name": "Shaft"}));+ run(&mut s, "solid.thread", json!({"face": [shaft / 2.0, 0, 11], "designation": "M6", "length": len, "modeled": true}));+ let ring = PI * (shaft * shaft / 4.0 - 9.0) * len;+ let want = PI * shaft * shaft / 4.0 * 12.0 - ring - groove;+ let got = volume(&mut s, "Shaft");+ assert!((got - want).abs() < groove * 0.03, "M6 on {shaft} mm: {got} mm³, want {want}");+ let st = s.model.state();+ let Some(b) = st.body("Shaft") else { panic!("no shaft") };+ assert!(b.body.validity().is_empty(), "{shaft} mm: {:?}", b.body.validity());+ // Nothing past the major diameter over the threaded length; the stub keeps its size.+ let round = |z: f64, r: f64| {+ (0..24).filter(|i| b.body.contains(Vec3::new(r * (PI * *i as f64 / 12.0).cos(), r * (PI * *i as f64 / 12.0).sin(), z))).count()+ };+ assert_eq!(round(8.0, 3.05), 0, "{shaft} mm: the threaded part is turned to 6 mm");+ assert_eq!(round(2.0, shaft / 2.0 - 0.05), 24, "{shaft} mm: the stub is whole");+ let names = solidcraft_doc::naming::face_names(b);+ let fid = s.doc.features.last().map(|f| f.id).unwrap_or(0);+ let named = |role: &str| names.iter().any(|n| n.starts_with(&format!("F{fid}:{role}")));+ assert_eq!(named("turned"), turned, "{shaft} mm: {names:?}");+ assert_eq!(named("shoulder:"), turned, "{shaft} mm: {names:?}");+ }++ // A 9 mm shaft is close enough to M8 to be offered it; it was refused as too thick (#2688).+ let mut s = Session::default();+ run(&mut s, "solid.cylinder", json!({"radius": 4.5, "height": 10, "body_name": "Shaft"}));+ run(&mut s, "solid.thread", json!({"face": [4.5, 0, 5], "designation": "M8", "modeled": true}));+ let root = 4.0 - 5.0 * 1.25 * 3f64.sqrt() / 16.0;+ let groove = per_turn(root, 4.0, |r| 1.25 / 4.0 + 2.0 * (r - root) * (PI / 6.0).tan()) * 10.0 / 1.25;+ let (want, got) = (PI * 16.0 * 10.0 - groove, volume(&mut s, "Shaft"));+ assert!((got - want).abs() < groove * 0.03, "M8 on 9 mm: {got} mm³, want {want}");+}++/// Issue 2705: an M14 over the top 10 mm of a 14.6 mm boss on a plate. Turned to 14 mm first:+/// 1600 + π 7.3² 15 − π (7.3² − 7²) 10 − 5 turns of 50.189 mm³ (tests/kernel-cases/threads/2705).+#[test]+fn an_m14_thread_on_a_14_6_mm_boss_turns_it_to_14_mm() {+ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"corner": [-10, -10, 0], "length": 20, "width": 20, "height": 4, "body_name": "Part"}));+ run(&mut s, "solid.cylinder", json!({"radius": 7.3, "height": 15, "base": [0, 0, 4], "operation": "join", "targets": ["Part"]}));+ run(&mut s, "solid.thread", json!({"face": [7.3, 0, 17], "designation": "M14", "length": 10, "modeled": true}));+ let got = volume(&mut s, "Part");+ assert!((got - 3725.5127).abs() < 3725.5127 * 0.01, "{got} mm³");+}++/// A shaft thinner than the thread's minor diameter is still refused, and so is a cosmetic+/// thread on a shaft thicker than it (a note changes nothing to turn). A shaft the part goes on+/// round (standing against a wall) is not turned into the wall.+#[test]+fn a_thin_shaft_or_one_the_part_surrounds_is_refused() {+ let refused = |s: &mut Session, body: &str, p: Value| {+ let before = volume(s, body);+ let e = s.execute("solid.thread", &p).err().map(|e| e.to_string()).unwrap_or_default();+ assert!((volume(s, body) - before).abs() < 1e-9, "{p}: {e}");+ e+ };+ let mut s = Session::default();+ run(&mut s, "solid.cylinder", json!({"radius": 2.4, "height": 10, "body_name": "Shaft"}));+ let e = refused(&mut s, "Shaft", json!({"face": [2.4, 0, 5], "designation": "M6", "modeled": true}));+ assert!(e.contains("does not fit a 4.80 mm shaft") || e.contains("too thin"), "{e}");++ let mut s = Session::default();+ run(&mut s, "solid.cylinder", json!({"radius": 4, "height": 10, "body_name": "Shaft"}));+ let e = refused(&mut s, "Shaft", json!({"face": [4, 0, 5], "designation": "M6"}));+ assert!(e.contains("an M6 thread does not fit a 8.00 mm shaft"), "{e}");++ let mut s = Session::default();+ run(&mut s, "solid.box", json!({"corner": [2, -10, 0], "length": 10, "width": 20, "height": 10, "body_name": "Part"}));+ run(&mut s, "solid.cylinder", json!({"radius": 4, "height": 10, "operation": "join", "targets": ["Part"]}));+ let e = refused(&mut s, "Part", json!({"face": [-4, 0, 5], "designation": "M6", "modeled": true}));+ assert!(e.contains("this 8 mm shaft is too thick for a modelled M6 thread") && e.contains("part around it"), "{e}");+}+#[test]fn non_finite_thread_designations_are_refused_without_changing_the_design() {let mut s = Session::default();@@ -174,9 +258,9 @@ fn a_modelled_thread_that_would_cut_nothing_is_refused() {/// Issue 2688: an M8 modelled thread in a 6 mm hole (narrower than its 6.65 mm minor diameter)/// was refused as "the face is too far from the thread's diameter". It says what is wrong and-/// what to drill, as a hole that is too wide does; and the same for a shaft that is too thick.+/// what to drill, as a hole that is too wide does. (A shaft too thick is turned down.)#[test]-fn a_hole_too_narrow_or_a_shaft_too_thick_says_which_and_what_fits() {+fn a_hole_too_narrow_says_so_and_what_fits() {let mut s = hex_nut(6.0);let before = volume(&mut s, "Nut");let e = s.execute("solid.thread", &json!({"face": [3.0, 0, 2], "designation": "M8", "modeled": true})).err().map(|e| e.to_string());@@ -184,13 +268,6 @@ fn a_hole_too_narrow_or_a_shaft_too_thick_says_which_and_what_fits() {assert!(e.contains("this 6 mm hole is too narrow for a modelled M8 thread") && e.contains("drill 6.75 mm for M8"), "{e}");assert!(!e.contains("too far"), "{e}");assert!((volume(&mut s, "Nut") - before).abs() < 1e-9);-- let mut s = Session::default();- // 9 mm is close enough to M8 to be offered it, too thick to cut it.- run(&mut s, "solid.cylinder", json!({"radius": 4.5, "height": 10, "body_name": "Shaft"}));- let e = s.execute("solid.thread", &json!({"face": [4.5, 0, 5], "designation": "M8", "modeled": true})).err().map(|e| e.to_string());- let e = e.unwrap_or_default();- assert!(e.contains("this 9 mm shaft is too thick for a modelled M8 thread") && e.contains("make the shaft 8 mm for M8"), "{e}");}/// The limit is a quarter of the basic depth 5H/8: a hole up to 4.78 mm for M5 (4.86 mm fordiff --git a/crates/ui-egui/src/preselect_tests.rs b/crates/ui-egui/src/preselect_tests.rsindex 5a1c16e583..85c2daef92 100644--- a/crates/ui-egui/src/preselect_tests.rs+++ b/crates/ui-egui/src/preselect_tests.rs@@ -1388,7 +1388,19 @@ fn modelled_thread_preview_updates_reports_errors_and_cancels_without_changes()designation(&mut h, "M8x1.3");wait_feature_preview(&mut h);assert_ne!(h.app.preview.key, first_key, "changing pitch updates the preview before OK");+ // An 8 mm shaft is turned down for an M6.+ let m8_key = h.app.preview.key;designation(&mut h, "M6x1.3");+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(120);+ while h.app.preview.key == m8_key && std::time::Instant::now() < deadline {+ h.frames(2);+ std::thread::sleep(std::time::Duration::from_millis(10));+ }+ wait_feature_preview(&mut h);+ assert!(h.app.preview.error.is_none(), "{:?}", h.app.preview.error);+ assert_eq!(h.app.preview.replaced, ["Body1"]);+ // A shaft thinner than the thread is still refused.+ designation(&mut h, "M10x1.5");for _ in 0..500 {h.frames(2);if !h.app.preview.busy && h.app.preview.error.is_some() {@@ -1398,7 +1410,7 @@ fn modelled_thread_preview_updates_reports_errors_and_cancels_without_changes()}assert!(h.app.preview.error.as_deref().is_some_and(|e| e.contains("does not fit")), "{:?}", h.app.preview.error);designation(&mut h, "M8x1.3");- // The M6 error stays until the new preview starts; wait for it to go, or+ // The M10 error stays until the new preview starts; wait for it to go, or// `wait_feature_preview` would stop at the stale error on a host that schedules the// preview a few frames later.let deadline = std::time::Instant::now() + std::time::Duration::from_secs(120);