diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rs index 00a9ff49f..fe0fd54cf 100644 --- a/crates/engine/src/cmd/features.rs +++ b/crates/engine/src/cmd/features.rs @@ -1883,6 +1883,59 @@ fn clearance_diameter(size: &str, fit: &str) -> Option { } } +/// The refusal for a thread designation `parse_metric_thread` does not know. A plain `M` with +/// a sane diameter but no ISO coarse pitch (M28, M7) gets two pitches to try: the largest common +/// pitch up to about an eighth of the diameter, and the next finer one. +fn unknown_metric_thread(t: &str, examples: &str) -> String { + fine_only_hint(t).unwrap_or_else(|| format!("unknown thread `{t}` (ISO metric, like {examples})")) +} + +/// The pitches to try for a plain `M` that has no ISO coarse pitch, `None` for anything else. +fn fine_only_hint(t: &str) -> Option { + const PITCHES: [f64; 9] = [2.0, 1.5, 1.25, 1.0, 0.75, 0.5, 0.35, 0.25, 0.2]; + let diameter = t.trim().strip_prefix(['M', 'm']).and_then(|d| d.trim().parse::().ok()); + if let Some(d) = diameter.filter(|d| d.is_finite() && *d > 0.2 && *d <= 1e4) { + let first = PITCHES.iter().position(|p| *p <= 0.12 * d).unwrap_or(PITCHES.len() - 1); + let pitches: Vec = PITCHES.iter().skip(first).take(2).filter(|p| **p < d).map(|p| format!("M{d}x{p}")).collect(); + if !pitches.is_empty() { + return Some(format!("M{d} has no coarse ISO pitch: give one, e.g. {}", pitches.join(" or "))); + } + } + None +} + +/// Largest nominal diameter automatic thread sizing knows (the last ISO coarse size). +const LARGEST_COARSE: f64 = 56.0; + +/// The refusal for automatic sizing on a cylinder too big for the coarse table (a Ø75 shaft): +/// `None` when sizing finds a thread, or the cylinder is not past the table's end (the feature's +/// own error then explains). It suggests sizes with a pitch to type, scaled to the diameter. +fn beyond_coarse_range(st: &solidcraft_doc::ModelState, face: Vec3) -> Option { + if solidcraft_doc::suggested_thread(st, face).is_ok() { + return None; + } + let cyl = st.bodies.iter().filter_map(|b| solidcraft_doc::kernel::cylinder_face_at(&b.body, face)).min_by(|a, b| { + let dist = + |c: &solidcraft_doc::kernel::CylinderFace| ((face - c.axis_point - c.axis * (face - c.axis_point).dot(c.axis)).len() - c.radius).abs(); + dist(a).total_cmp(&dist(b)) + })?; + let dia = cyl.radius * 2.0; + if !dia.is_finite() || dia <= LARGEST_COARSE * 0.9 || dia > 1e4 { + return None; + } + // ISO fine pitches for large sizes: the largest up to about a 25th of the diameter, then the + // next finer one. A hole's major diameter is about its bore plus one pitch. + const PITCHES: [f64; 4] = [4.0, 3.0, 2.0, 1.5]; + let first = PITCHES.iter().position(|p| *p <= dia / 25.0 + 1e-6).unwrap_or(PITCHES.len() - 1); + let sizes: Vec = + PITCHES.iter().skip(first).take(2).map(|p| format!("M{}x{p}", if cyl.internal { dia + p } else { dia }.round())).collect(); + let kind = if cyl.internal { "hole" } else { "cylinder" }; + Some(format!( + "a {dia:.2} mm {kind} is beyond the coarse thread range (up to M{LARGEST_COARSE}): type a size with its pitch, e.g. {}", + sizes.join(" or ") + )) +} + fn hole(s: &mut Session, p: &Value) -> Result { let cmd = "solid.hole"; // At sketch points: the holes go perpendicular to the sketch and follow its points. @@ -1920,7 +1973,10 @@ fn hole(s: &mut Session, p: &Value) -> Result { if let Some(t) = &thread && solidcraft_doc::parse_tapped_thread(t).is_none() { - return Err(bad(cmd, format!("unknown tapped thread `{t}` (ISO metric or a catalogued UNC/UNF, G or Rp size)"))); + return Err(bad( + cmd, + fine_only_hint(t).unwrap_or_else(|| format!("unknown tapped thread `{t}` (ISO metric or a catalogued UNC/UNF, G or Rp size)")), + )); } // A position given as length expressions (#1678), say `["leg_h*0.4", "width/2", "t"]`: kept, // so the hole follows the parameters; drilled where they evaluate now. @@ -2354,13 +2410,18 @@ fn thread(s: &mut Session, p: &Value) -> Result { if let Some(t) = &designation && solidcraft_doc::parse_metric_thread(t).is_none() { - return Err(bad(cmd, format!("unknown thread `{t}` (ISO metric, like M8 or M8x1)"))); + return Err(bad(cmd, unknown_metric_thread(t, "M8 or M8x1"))); } let length = expr(p, "length"); if let Some(l) = &length { check_expr(s, l, Kind::Length, cmd, "length")?; } let modeled = p.get("modeled").and_then(Value::as_bool).unwrap_or(false); + if designation.is_none() + && let Some(msg) = beyond_coarse_range(&s.model.state(), face) + { + return Err(bad(cmd, msg)); + } let v = add_feature(s, p, FeatureKind::Thread { face: FacePick(face), designation, length, modeled })?; let st = s.model.state(); let t = v.get("feature").and_then(Value::as_u64).and_then(|id| st.threads.iter().find(|t| t.feature == id).cloned()); diff --git a/crates/engine/src/thread_tests.rs b/crates/engine/src/thread_tests.rs index 7778a3a81..52b10e8bf 100644 --- a/crates/engine/src/thread_tests.rs +++ b/crates/engine/src/thread_tests.rs @@ -176,6 +176,45 @@ fn a_thin_shaft_or_one_the_part_surrounds_is_refused() { assert!(e.contains("this 8 mm shaft is too thick for a modelled M6 thread") && e.contains("part around it"), "{e}"); } +#[test] +fn a_thread_without_a_coarse_pitch_suggests_explicit_pitches() { + let mut s = Session::default(); + run(&mut s, "solid.cylinder", json!({"radius": 14, "height": 10, "body_name": "Shaft"})); + let saved = s.doc.to_json(); + for designation in ["M28", "m28", " M28 "] { + let e = s.execute("solid.thread", &json!({"face": [14, 0, 5], "designation": designation})).unwrap_err().to_string(); + assert!(e.contains("has no coarse ISO pitch") && e.contains("M28x2") && e.contains("M28x1.5"), "{e}"); + assert_eq!(s.doc.to_json(), saved); + } + for designation in ["MNaN", "Minf", "M-28", "M0", "M1e9", "M1e999", "M28x", "M28xNaN"] { + let e = s.execute("solid.thread", &json!({"face": [14, 0, 5], "designation": designation})).unwrap_err().to_string(); + assert!(e.contains("unknown thread"), "{designation}: {e}"); + assert_eq!(s.doc.to_json(), saved); + } + run(&mut s, "solid.thread", json!({"face": [14, 0, 5], "designation": "M28x2"})); +} + +#[test] +fn automatic_sizing_past_the_coarse_range_suggests_a_size_with_its_pitch() { + let mut s = Session::default(); + run(&mut s, "solid.cylinder", json!({"radius": 37.5, "height": 10, "body_name": "Shaft"})); + let saved = s.doc.to_json(); + let e = s.execute("solid.thread", &json!({"face": [37.5, 0, 5]})).unwrap_err().to_string(); + assert!(e.contains("beyond the coarse thread range (up to M56)") && e.contains("M75x3 or M75x2"), "{e}"); + assert_eq!(s.doc.to_json(), saved); + run(&mut s, "solid.thread", json!({"face": [37.5, 0, 5], "designation": "M75x2"})); +} + +#[test] +fn a_threaded_hole_without_a_coarse_pitch_suggests_explicit_pitches() { + let mut s = Session::default(); + run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 10})); + let saved = s.doc.to_json(); + let e = s.execute("solid.hole", &json!({"position": [20, 20, 10], "thread": "M28"})).unwrap_err().to_string(); + assert!(e.contains("has no coarse ISO pitch") && e.contains("M28x2") && e.contains("M28x1.5"), "{e}"); + assert_eq!(s.doc.to_json(), saved); +} + #[test] fn non_finite_thread_designations_are_refused_without_changing_the_design() { let mut s = Session::default();