diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index 29ec73ce2..f673c785f 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 { - 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) -> Result { +/// 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, turned: bool) -> Result { 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 Result> { + 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 { + 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, 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, 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, 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.rs index 9c26734ad..6664de789 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.rs index 5f12c78fc..7778a3a81 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 for diff --git a/crates/ui-egui/src/preselect_tests.rs b/crates/ui-egui/src/preselect_tests.rs index 5a1c16e58..85c2daef9 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);