diff --git a/assets/locales/pending/inch-fasteners.json b/assets/locales/pending/inch-fasteners.json new file mode 100644 index 000000000..2c7142b48 --- /dev/null +++ b/assets/locales/pending/inch-fasteners.json @@ -0,0 +1,83 @@ +{ + "en": { + "parts.family.hex_cap_screw_inch": "Hex cap screw (inch)", + "parts.family.hex_nut_inch": "Hex nut (inch)", + "parts.family.washer_sae": "Plain washer, SAE (narrow)", + "parts.family.washer_uss": "Plain washer, USS (wide)", + "parts.system": "Unit system", + "parts.system.inch": "Inch", + "parts.system.metric": "Metric" + }, + "ar": { + "parts.family.hex_cap_screw_inch": "برغي سداسي الرأس (بوصة)", + "parts.family.hex_nut_inch": "صامولة سداسية (بوصة)", + "parts.family.washer_sae": "حلقة مسطحة، SAE (ضيقة)", + "parts.family.washer_uss": "حلقة مسطحة، USS (عريضة)", + "parts.system": "نظام الوحدات", + "parts.system.inch": "بوصة", + "parts.system.metric": "متري" + }, + "he": { + "parts.family.hex_cap_screw_inch": "בורג ראש משושה (אינץ')", + "parts.family.hex_nut_inch": "אום משושה (אינץ')", + "parts.family.washer_sae": "דסקית שטוחה, SAE (צרה)", + "parts.family.washer_uss": "דסקית שטוחה, USS (רחבה)", + "parts.system": "מערכת יחידות", + "parts.system.inch": "אינץ'", + "parts.system.metric": "מטרי" + }, + "ja": { + "parts.family.hex_cap_screw_inch": "六角ボルト(インチ)", + "parts.family.hex_nut_inch": "六角ナット(インチ)", + "parts.family.washer_sae": "平座金、SAE(小形)", + "parts.family.washer_uss": "平座金、USS(大形)", + "parts.system": "単位系", + "parts.system.inch": "インチ", + "parts.system.metric": "メートル" + }, + "vi": { + "parts.family.hex_cap_screw_inch": "Bu lông đầu lục giác (inch)", + "parts.family.hex_nut_inch": "Đai ốc lục giác (inch)", + "parts.family.washer_sae": "Vòng đệm phẳng, SAE (hẹp)", + "parts.family.washer_uss": "Vòng đệm phẳng, USS (rộng)", + "parts.system": "Hệ đơn vị", + "parts.system.inch": "Inch", + "parts.system.metric": "Hệ mét" + }, + "zh": { + "parts.family.hex_cap_screw_inch": "六角头螺栓(英制)", + "parts.family.hex_nut_inch": "六角螺母(英制)", + "parts.family.washer_sae": "平垫圈,SAE(窄型)", + "parts.family.washer_uss": "平垫圈,USS(宽型)", + "parts.system": "单位制", + "parts.system.inch": "英制", + "parts.system.metric": "公制" + }, + "de": { + "parts.family.hex_cap_screw_inch": "Sechskantschraube (Zoll)", + "parts.family.hex_nut_inch": "Sechskantmutter (Zoll)", + "parts.family.washer_sae": "Unterlegscheibe, SAE (schmal)", + "parts.family.washer_uss": "Unterlegscheibe, USS (breit)", + "parts.system": "Maßsystem", + "parts.system.inch": "Zoll", + "parts.system.metric": "Metrisch" + }, + "es": { + "parts.family.hex_cap_screw_inch": "Tornillo de cabeza hexagonal (pulgadas)", + "parts.family.hex_nut_inch": "Tuerca hexagonal (pulgadas)", + "parts.family.washer_sae": "Arandela plana, SAE (estrecha)", + "parts.family.washer_uss": "Arandela plana, USS (ancha)", + "parts.system": "Sistema de unidades", + "parts.system.inch": "Pulgadas", + "parts.system.metric": "Métrico" + }, + "fr": { + "parts.family.hex_cap_screw_inch": "Vis à tête hexagonale (pouces)", + "parts.family.hex_nut_inch": "Écrou hexagonal (pouces)", + "parts.family.washer_sae": "Rondelle plate, SAE (étroite)", + "parts.family.washer_uss": "Rondelle plate, USS (large)", + "parts.system": "Système d'unités", + "parts.system.inch": "Pouces", + "parts.system.metric": "Métrique" + } +} diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs index 388074395..a7d3ba547 100644 --- a/crates/engine/src/cmd/mod.rs +++ b/crates/engine/src/cmd/mod.rs @@ -47,6 +47,7 @@ pub(crate) use features::{EdgeRefForm, PLANE_FORMS, axis_dir_form, axis_line_obj pub use features::{auto_operation, extrude_reach, shown_scope}; pub use file::open_steps::OpenSteps; pub use join_pieces::{Addition, addition}; +pub use parts::part_length_label; pub use sketch::dimension_roles; pub(crate) use sketch::face::face_pick_form; pub use sketch_construction::{ diff --git a/crates/engine/src/cmd/parts.rs b/crates/engine/src/cmd/parts.rs index 1a9c9a907..692144050 100644 --- a/crates/engine/src/cmd/parts.rs +++ b/crates/engine/src/cmd/parts.rs @@ -1,5 +1,6 @@ -//! Standard parts: ISO metric fasteners, dowel pins and ball bearings, generated in code from -//! the dimensions in the public standards tables (no vendor geometry). Each part is inserted as +//! Standard parts: ISO metric and ASME/ANSI inch fasteners, dowel pins and ball bearings, +//! generated in code from the dimensions in the public standards tables (no vendor geometry). +//! Inch parts are tabled in inches and built in millimetres like the rest. Each part is inserted as //! its own component, built by ordinary features (so it stays parametric and editable), with a //! cosmetic thread where it has one; at a hole it gets a rigid joint that puts its axis on the //! hole's and seats it on the face. Inserted at several holes it is still one component, placed @@ -16,20 +17,24 @@ use crate::params::{bad, num, str_, vec3}; use crate::{EngineError, Result, Session}; pub static COMMANDS: &[CommandSpec] = &[ - CommandSpec::new("parts.library", "Standard Parts", library).icon("library") + CommandSpec::new("parts.library", "Standard Parts", library) + .icon("library") .noundo() - .params("family? → families (name, standard, sizes, lengths) and, with family, each size's dimensions (mm)"), - CommandSpec::new("parts.fastener", "Insert Fastener", insert_atomic).at("SOLID", "INSERT").icon("fastener").params( - "the Insert Part dialog's command (same as parts.insert): family, size, length?, at?|point?+direction?, name?", - ), + .params("family? → families (name, standard, system: metric|inch, sizes, lengths) and, with family, each size's dimensions (mm)"), + CommandSpec::new("parts.fastener", "Insert Fastener", insert_atomic) + .at("SOLID", "INSERT") + .icon("fastener") + .params("the Insert Part dialog's command (same as parts.insert): family, size, length?, at?|point?+direction?, name?"), CommandSpec::new("parts.insert", "Insert Part", insert_atomic).icon("fastener").params( - "family (socket_head_cap_screw | button_head_cap_screw | hex_bolt | hex_nut | washer | set_screw | dowel_pin | bearing); size (\"M6\", or \"608\" for bearings); \ - length? (mm; screws, bolts, set screws, pins; default a standard length near 2.5 d); \ + "family (socket_head_cap_screw | button_head_cap_screw | hex_bolt | hex_nut | washer | set_screw | dowel_pin | bearing | \ + hex_cap_screw_inch | hex_nut_inch | washer_sae | washer_uss); size (\"M6\", \"608\" for bearings, \"1/2-13 UNC\" for inch screws and nuts, \ + \"1/2\" for inch washers); length? (mm, inch parts too; screws, bolts, set screws, pins; default a standard length near 2.5 d); \ at?: [x,y,z] on a hole's rim or wall (the part seats on the hole's face with a rigid joint), or a list of them (one component, \ placed and seated once per hole) | point?: [x,y,z] with direction?: [x,y,z] (no joint); name? → component, occurrence, joint?, \ and with at: occurrences, joints (one per hole, in pick order)", ), - CommandSpec::new("parts.resize", "Change Part Size", resize_atomic).icon("scale") + CommandSpec::new("parts.resize", "Change Part Size", resize_atomic) + .icon("scale") .params("component: id|name of an inserted part; size?; length? — rebuilds it (joints keep it seated)"), ]; @@ -43,6 +48,10 @@ const FAMILIES: &[(&str, &str, &str)] = &[ ("set_screw", "Hex socket set screw, flat point", "ISO 4026"), ("dowel_pin", "Parallel pin (dowel)", "ISO 8734"), ("bearing", "Deep groove ball bearing (envelope)", "ISO 15 (6000/6200/600 series)"), + ("hex_cap_screw_inch", "Hex cap screw (inch)", "ASME B18.2.1"), + ("hex_nut_inch", "Hex nut (inch)", "ASME B18.2.2"), + ("washer_sae", "Plain washer, SAE (narrow)", "ANSI B18.22.1 Type A"), + ("washer_uss", "Plain washer, USS (wide)", "ANSI B18.22.1 Type A"), ]; /// ISO metric coarse: (size, d, pitch). @@ -190,6 +199,127 @@ const BEARINGS: [(&str, f64, f64, f64); 13] = [ const LENGTHS: [f64; 22] = [4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 16.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 55.0, 60.0, 65.0, 70.0, 80.0, 90.0, 100.0, 120.0]; +/// Millimetres per inch. +const INCH: f64 = 25.4; + +/// ASME B18.2.1 hex cap screw, in inches: (nominal size, width across flats F, head height H). +/// 9/16 is left out until the thread catalogue has its UNC and UNF threads. +const INCH_HEX_CAP: [(&str, f64, f64); 9] = [ + ("1/4", 0.4375, 0.156), + ("5/16", 0.5, 0.203), + ("3/8", 0.5625, 0.234), + ("7/16", 0.625, 0.281), + ("1/2", 0.75, 0.312), + ("5/8", 0.9375, 0.391), + ("3/4", 1.125, 0.469), + ("7/8", 1.3125, 0.547), + ("1", 1.5, 0.609), +]; + +/// ASME B18.2.2 hex nut, in inches: (nominal size, width across flats F, thickness H). +const INCH_HEX_NUT: [(&str, f64, f64); 9] = [ + ("1/4", 0.4375, 0.219), + ("5/16", 0.5, 0.266), + ("3/8", 0.5625, 0.328), + ("7/16", 0.6875, 0.375), + ("1/2", 0.75, 0.438), + ("5/8", 0.9375, 0.547), + ("3/4", 1.125, 0.641), + ("7/8", 1.3125, 0.75), + ("1", 1.5, 0.859), +]; + +/// ANSI B18.22.1 Type A plain washers, in inches: (nominal size, inside diameter, outside +/// diameter, thickness). SAE is the standard's narrow (N) series, USS its wide (W) one. +const WASHER_SAE: [(&str, f64, f64, f64); 9] = [ + ("1/4", 0.281, 0.625, 0.065), + ("5/16", 0.344, 0.688, 0.065), + ("3/8", 0.406, 0.812, 0.065), + ("7/16", 0.469, 0.922, 0.065), + ("1/2", 0.531, 1.062, 0.095), + ("5/8", 0.656, 1.312, 0.095), + ("3/4", 0.812, 1.469, 0.134), + ("7/8", 0.938, 1.75, 0.134), + ("1", 1.062, 2.0, 0.134), +]; +const WASHER_USS: [(&str, f64, f64, f64); 9] = [ + ("1/4", 0.312, 0.734, 0.065), + ("5/16", 0.375, 0.875, 0.083), + ("3/8", 0.438, 1.0, 0.083), + ("7/16", 0.5, 1.25, 0.083), + ("1/2", 0.562, 1.375, 0.109), + ("5/8", 0.688, 1.75, 0.134), + ("3/4", 0.812, 2.0, 0.148), + ("7/8", 0.938, 2.25, 0.165), + ("1", 1.062, 2.5, 0.165), +]; + +/// Standard lengths for inch cap screws (inches). +const INCH_LENGTHS: [f64; 19] = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 7.0, 8.0]; + +fn inch_lengths() -> Vec { + INCH_LENGTHS.iter().map(|l| l * INCH).collect() +} + +/// The first standard length at or above 2.5 d. Both sides are inches turned into mm, so the +/// comparison allows for rounding: a 1/2 screw's 2.5 d is exactly 1-1/4. +fn default_inch_length(d: f64) -> f64 { + inch_lengths().into_iter().find(|l| *l >= 2.5 * d - 1e-9).unwrap_or(8.0 * INCH) +} + +fn is_inch(family: &str) -> bool { + matches!(family, "hex_cap_screw_inch" | "hex_nut_inch" | "washer_sae" | "washer_uss") +} + +/// A unified inch thread from the catalogue (`1/2-13 UNC`): its nominal size (`1/2`), and its +/// major diameter and pitch (mm). +fn unified(size: &str) -> Option<(String, f64, f64)> { + use solidcraft_doc::TappedThreadFamily::{Unc, Unf}; + let t = solidcraft_doc::parse_tapped_thread(size).filter(|t| matches!(t.family, Unc | Unf))?; + let nominal = t.designation.split('-').next()?.to_string(); + Some((nominal, t.major_diameter, t.pitch)) +} + +/// The catalogue's threads for a nominal inch size, UNC before UNF. +fn unified_sizes(nominal: &str) -> Vec { + use solidcraft_doc::TappedThreadFamily::{Unc, Unf}; + [Unc, Unf].into_iter().flat_map(solidcraft_doc::tapped_thread_sizes).filter(|t| t.designation.split('-').next() == Some(nominal)).collect() +} + +/// A length (mm) in fractional inches to the nearest 1/64 (`1-1/2`), or none off that grid. +fn inch_fraction(mm: f64) -> Option { + let n = mm / INCH * 64.0; + let r = n.round(); + if !r.is_finite() || r <= 0.0 || r > 1e6 || (n - r).abs() > 1e-6 { + return None; + } + let r = r as u64; + let (whole, mut num, mut den) = (r / 64, r % 64, 64); + while num > 0 && num % 2 == 0 { + num /= 2; + den /= 2; + } + Some(match (whole, num) { + (w, 0) => w.to_string(), + (0, n) => format!("{n}/{den}"), + (w, n) => format!("{w}-{n}/{den}"), + }) +} + +/// How a part's length (mm) is shown where its family has a unit of its own: `1-1/2 in` for an +/// inch family, none for a metric one (shown in the design's units). +pub fn part_length_label(family: &str, mm: f64) -> Option { + is_inch(family).then(|| inch_fraction(mm)).flatten().map(|f| format!("{f} in")) +} + +/// A part's size with its length, as names and part numbers write it: `M6x20`, `1/2-13 UNC x 2`. +fn size_with_length(family: &str, size: &str, len: f64) -> String { + match is_inch(family).then(|| inch_fraction(len)).flatten() { + Some(l) => format!("{size} x {l}"), + None => format!("{size}x{len}"), + } +} + fn metric(size: &str) -> Option<(f64, f64)> { METRIC.iter().find(|(s, _, _)| s.eq_ignore_ascii_case(size)).map(|(_, d, p)| (*d, *p)) } @@ -202,9 +332,11 @@ fn default_length(d: f64) -> f64 { #[derive(Clone, Debug, PartialEq)] enum Shape { /// A head (round, domed or hex), a shank down −z, an optional hex socket in the head's top. - Screw { d: f64, pitch: f64, len: f64, head: Head, socket: Option<(f64, f64)> }, + /// `pitch` is that of a metric cosmetic thread; inch parts have none, as `solid.thread` takes + /// only metric designations (#9571). + Screw { d: f64, pitch: Option, len: f64, head: Head, socket: Option<(f64, f64)> }, /// A hex prism with a through hole (nut), z 0…m. - Nut { d: f64, pitch: f64, s: f64, m: f64 }, + Nut { d: f64, pitch: Option, s: f64, m: f64 }, /// A ring (washer, bearing envelope), z 0…h. Ring { d_in: f64, d_out: f64, h: f64 }, /// A cylinder down −z with a socket in its top (set screw), or plain (pin). @@ -237,22 +369,43 @@ fn shape(family: &str, size: &str, length: Option) -> std::result::Result { let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?; let (_, dk, k, s, t) = SHCS.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 4762"))?; - Shape::Screw { d, pitch, len: len(d), head: Head::Round { dk, k }, socket: Some((s, t)) } + Shape::Screw { d, pitch: Some(pitch), len: len(d), head: Head::Round { dk, k }, socket: Some((s, t)) } } "button_head_cap_screw" => { let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?; let (_, dk, k, s, t) = BHCS.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 7380-1"))?; - Shape::Screw { d, pitch, len: len(d), head: Head::Dome { dk, k, flat: BUTTON_FLAT * s }, socket: Some((s, t)) } + Shape::Screw { d, pitch: Some(pitch), len: len(d), head: Head::Dome { dk, k, flat: BUTTON_FLAT * s }, socket: Some((s, t)) } } "hex_bolt" => { let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?; let (_, s, k) = HEX_BOLT.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 4014"))?; - Shape::Screw { d, pitch, len: len(d), head: Head::Hex { s, k }, socket: None } + Shape::Screw { d, pitch: Some(pitch), len: len(d), head: Head::Hex { s, k }, socket: None } } "hex_nut" => { let (d, pitch) = metric(size).ok_or_else(|| need("metric"))?; let (_, s, m) = HEX_NUT.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 4032"))?; - Shape::Nut { d, pitch, s, m } + Shape::Nut { d, pitch: Some(pitch), s, m } + } + "hex_cap_screw_inch" => { + let (nominal, d, _) = unified(size).ok_or_else(|| need("UNC/UNF"))?; + let (_, f, h) = INCH_HEX_CAP.iter().find(|r| r.0 == nominal).copied().ok_or_else(|| need("ASME B18.2.1"))?; + Shape::Screw { + d, + pitch: None, + len: length.unwrap_or_else(|| default_inch_length(d)), + head: Head::Hex { s: f * INCH, k: h * INCH }, + socket: None, + } + } + "hex_nut_inch" => { + let (nominal, d, _) = unified(size).ok_or_else(|| need("UNC/UNF"))?; + let (_, f, h) = INCH_HEX_NUT.iter().find(|r| r.0 == nominal).copied().ok_or_else(|| need("ASME B18.2.2"))?; + Shape::Nut { d, pitch: None, s: f * INCH, m: h * INCH } + } + "washer_sae" | "washer_uss" => { + let table = if family == "washer_sae" { &WASHER_SAE } else { &WASHER_USS }; + let (_, d1, d2, h) = table.iter().find(|r| r.0 == size.trim()).copied().ok_or_else(|| need("ANSI B18.22.1"))?; + Shape::Ring { d_in: d1 * INCH, d_out: d2 * INCH, h: h * INCH } } "washer" => { let (_, d1, d2, h) = WASHER.iter().find(|r| r.0.eq_ignore_ascii_case(size)).copied().ok_or_else(|| need("ISO 7089"))?; @@ -390,12 +543,16 @@ fn build(s: &mut Session, sh: &Shape) -> Result<()> { if let Some((af, t)) = socket { hex(s, af, k, k - t, "cut")?; } - thread(s, d, pitch, Vec3::new(d / 2.0, 0.0, -len / 2.0)); + if let Some(p) = pitch { + thread(s, d, p, Vec3::new(d / 2.0, 0.0, -len / 2.0)); + } } Shape::Nut { d, pitch, s: af, m } => { hex(s, af, 0.0, m, "new")?; cyl(s, d, -1.0, m + 1.0, "cut")?; - thread(s, d, pitch, Vec3::new(d / 2.0, 0.0, m / 2.0)); + if let Some(p) = pitch { + thread(s, d, p, Vec3::new(d / 2.0, 0.0, m / 2.0)); + } } Shape::Ring { d_in, d_out, h } => { revolve(s, &[(d_in / 2.0, 0.0), (d_out / 2.0, 0.0), (d_out / 2.0, h), (d_in / 2.0, h)], "new")?; @@ -424,11 +581,26 @@ fn library(_s: &mut Session, p: &Value) -> Result { "set_screw" => SET_SCREW.iter().map(|r| json!({"size": r.0, "d": metric(r.0).map(|m| m.0), "pitch": metric(r.0).map(|m| m.1), "socket": r.1, "socket_depth": r.2})).collect(), "dowel_pin" => DOWEL.iter().map(|d| json!({"size": format!("{d}"), "d": d})).collect(), "bearing" => BEARINGS.iter().map(|r| json!({"size": r.0, "bore": r.1, "outer": r.2, "width": r.3})).collect(), + "hex_cap_screw_inch" => INCH_HEX_CAP + .iter() + .flat_map(|r| unified_sizes(r.0).into_iter().map(move |t| json!({"size": t.designation, "d": t.major_diameter, "pitch": t.pitch, "across_flats": r.1 * INCH, "head_height": r.2 * INCH}))) + .collect(), + "hex_nut_inch" => INCH_HEX_NUT + .iter() + .flat_map(|r| unified_sizes(r.0).into_iter().map(move |t| json!({"size": t.designation, "d": t.major_diameter, "pitch": t.pitch, "across_flats": r.1 * INCH, "height": r.2 * INCH}))) + .collect(), + "washer_sae" | "washer_uss" => { + let table = if id == "washer_sae" { &WASHER_SAE } else { &WASHER_USS }; + table.iter().map(|r| json!({"size": r.0, "inner": r.1 * INCH, "outer": r.2 * INCH, "thickness": r.3 * INCH})).collect() + } _ => Vec::new(), }; let (_, name, standard) = FAMILIES.iter().find(|f| f.0 == id).copied().unwrap_or(("", "", "")); - let lengths = - matches!(id, "socket_head_cap_screw" | "button_head_cap_screw" | "hex_bolt" | "set_screw" | "dowel_pin").then_some(LENGTHS.to_vec()); + let lengths = match id { + "socket_head_cap_screw" | "button_head_cap_screw" | "hex_bolt" | "set_screw" | "dowel_pin" => Some(LENGTHS.to_vec()), + "hex_cap_screw_inch" => Some(inch_lengths()), + _ => None, + }; if lengths.is_some() { for row in &mut sizes { let Some(size) = row.get("size").and_then(Value::as_str).map(str::to_string) else { continue }; @@ -438,7 +610,8 @@ fn library(_s: &mut Session, p: &Value) -> Result { } } } - json!({"family": id, "name": name, "standard": standard, "sizes": sizes, "lengths": lengths}) + let system = if is_inch(id) { "inch" } else { "metric" }; + json!({"family": id, "name": name, "standard": standard, "system": system, "sizes": sizes, "lengths": lengths}) }; match str_(p, "family") { Some(f) if FAMILIES.iter().any(|x| x.0 == f) => Ok(fam(f)), @@ -449,16 +622,17 @@ fn library(_s: &mut Session, p: &Value) -> Result { fn part_name(family: &str, size: &str, sh: &Shape) -> String { match sh { - Shape::Screw { len, .. } | Shape::Rod { len, .. } => format!("{} {size}x{len}", label(family)), + Shape::Screw { len, .. } | Shape::Rod { len, .. } => format!("{} {}", label(family), size_with_length(family, size, *len)), _ => format!("{} {size}", label(family)), } } -/// A standard part's part number and description: its standard and size (`ISO 4762 M6x20`), or -/// a bearing's designation, and the family's name with the size. +/// A standard part's part number and description: its standard and size (`ISO 4762 M6x20`, +/// `ASME B18.2.1 1/2-13 UNC x 2`, an inch washer with its series: `ANSI B18.22.1 1/2 N`), or a +/// bearing's designation, and the family's name with the size. fn identity(family: &str, size: &str, sh: &Shape) -> (String, String) { let size = match sh { - Shape::Screw { len, .. } | Shape::Rod { len, .. } => format!("{size}x{len}"), + Shape::Screw { len, .. } | Shape::Rod { len, .. } => size_with_length(family, size, *len), _ => size.to_string(), }; let standard = match family { @@ -469,10 +643,18 @@ fn identity(family: &str, size: &str, sh: &Shape) -> (String, String) { "washer" => "ISO 7089", "set_screw" => "ISO 4026", "dowel_pin" => "ISO 8734", + "hex_cap_screw_inch" => "ASME B18.2.1", + "hex_nut_inch" => "ASME B18.2.2", + "washer_sae" | "washer_uss" => "ANSI B18.22.1", + _ => "", + }; + let series = match family { + "washer_sae" => " N", + "washer_uss" => " W", _ => "", }; let name = FAMILIES.iter().find(|f| f.0 == family).map_or("Part", |f| f.1); - let part_number = if standard.is_empty() { size.clone() } else { format!("{standard} {size}") }; + let part_number = if standard.is_empty() { size.clone() } else { format!("{standard} {size}{series}") }; (part_number, format!("{name} {size}")) } @@ -503,6 +685,10 @@ fn label(family: &str) -> &'static str { "washer" => "Washer", "set_screw" => "Set Screw", "dowel_pin" => "Dowel Pin", + "hex_cap_screw_inch" => "Hex Cap Screw", + "hex_nut_inch" => "Hex Nut", + "washer_sae" => "SAE Washer", + "washer_uss" => "USS Washer", _ => "Bearing", } } @@ -777,6 +963,93 @@ mod tests { } } + /// #10316: ASME/ANSI inch hex cap screws, hex nuts and SAE/USS washers, tabled in inches and + /// built in millimetres, with sizes from the UNC/UNF thread catalogue and fractional-inch names. + #[test] + fn inch_parts_follow_the_asme_and_ansi_tables() { + const IN: f64 = 25.4; + let across_corners = |af: f64| af / (std::f64::consts::PI / 6.0).cos(); + let part_number = |s: &Session, out: &Value| { + let comp = out["component"].as_u64().unwrap_or(0); + s.doc.components.iter().find(|c| c.id == comp).and_then(|c| c.metadata.text(solidcraft_doc::metadata::PART_NUMBER)).map(str::to_string) + }; + // Every nominal size 1/4 to 1 but 9/16, coarse and fine. + let l = run(&mut Session::default(), "parts.library", json!({"family": "hex_cap_screw_inch"})); + let sizes: Vec<&str> = l["sizes"].as_array().map(|a| a.iter().filter_map(|x| x["size"].as_str()).collect()).unwrap_or_default(); + assert_eq!(sizes.len(), 18, "{sizes:?}"); + assert_eq!(sizes[..2], ["1/4-20 UNC", "1/4-28 UNF"]); + assert_eq!(sizes[16..], ["1-8 UNC", "1-12 UNF"]); + assert_eq!((l["standard"].as_str(), l["system"].as_str()), (Some("ASME B18.2.1"), Some("inch"))); + let all = run(&mut Session::default(), "parts.library", json!({})); + let inch: Vec<&str> = all["families"] + .as_array() + .map(|a| a.iter().filter(|f| f["system"] == "inch").filter_map(|f| f["family"].as_str()).collect()) + .unwrap_or_default(); + assert_eq!(inch, ["hex_cap_screw_inch", "hex_nut_inch", "washer_sae", "washer_uss"]); + let lengths: Vec = l["lengths"].as_array().map(|a| a.iter().filter_map(Value::as_f64).collect()).unwrap_or_default(); + assert_eq!((lengths.first().copied(), lengths.last().copied(), lengths.len()), (Some(0.5 * IN), Some(8.0 * IN), 19)); + // A 1/2-13 x 2 cap screw: 3/4 across flats, head 0.312 high, shank 2 in long, no thread mark. + let mut s = Session::default(); + let out = run(&mut s, "parts.insert", json!({"family": "hex_cap_screw_inch", "size": "1/2-13 UNC", "length": 2.0 * IN})); + assert_eq!(out["name"], "Hex Cap Screw 1/2-13 UNC x 2"); + assert_eq!(part_number(&s, &out).as_deref(), Some("ASME B18.2.1 1/2-13 UNC x 2")); + let (lo, hi) = bbox(&s, "Hex Cap Screw 1/2-13 UNC x 2"); + let w = (hi.x - lo.x).max(hi.y - lo.y); + assert!((w - across_corners(0.75 * IN)).abs() < 1e-6 && (lo.z + 2.0 * IN).abs() < 1e-6 && (hi.z - 0.312 * IN).abs() < 1e-6, "{lo:?} {hi:?}"); + assert!(s.model.state().threads.is_empty(), "solid.thread takes only metric designations (#9571)"); + // Its default length is the first standard length at or above 2.5 d: 1-1/4 for a 1/2. + let mut d = Session::default(); + assert_eq!( + run(&mut d, "parts.insert", json!({"family": "hex_cap_screw_inch", "size": "1/2-20 UNF"}))["name"], + "Hex Cap Screw 1/2-20 UNF x 1-1/4" + ); + // A 1/2-13 nut: 3/4 across flats, 0.438 thick, with the 1/2 in hole through it. + let mut n = Session::default(); + let out = run(&mut n, "parts.insert", json!({"family": "hex_nut_inch", "size": "1/2-13 UNC"})); + assert_eq!(part_number(&n, &out).as_deref(), Some("ASME B18.2.2 1/2-13 UNC")); + let (lo, hi) = bbox(&n, "Hex Nut 1/2-13 UNC"); + let (w, h) = ((hi.x - lo.x).max(hi.y - lo.y), hi.z - lo.z); + assert!((w - across_corners(0.75 * IN)).abs() < 1e-6 && (h - 0.438 * IN).abs() < 1e-6, "{w} {h}"); + // 1/2 washers: SAE 1.062 x 0.095, USS 1.375 x 0.109, the series in the part number. + for (family, label, od, t, number) in [ + ("washer_sae", "SAE Washer 1/2", 1.062, 0.095, "ANSI B18.22.1 1/2 N"), + ("washer_uss", "USS Washer 1/2", 1.375, 0.109, "ANSI B18.22.1 1/2 W"), + ] { + let mut w = Session::default(); + let out = run(&mut w, "parts.insert", json!({"family": family, "size": "1/2"})); + assert_eq!(part_number(&w, &out).as_deref(), Some(number)); + let (lo, hi) = bbox(&w, label); + assert!((hi.x - lo.x - od * IN).abs() < 1e-6 && (hi.z - lo.z - t * IN).abs() < 1e-6, "{family}: {lo:?} {hi:?}"); + } + // Resizing keeps it inch, and sizes the tables don't have are refused. + let r = run(&mut s, "parts.resize", json!({"component": "Hex Cap Screw 1/2-13 UNC x 2", "size": "3/8-16 UNC", "length": 1.0 * IN})); + assert_eq!(r["name"], "Hex Cap Screw 3/8-16 UNC x 1"); + for (family, size) in [ + ("hex_cap_screw_inch", "9/16-12 UNC"), + ("hex_cap_screw_inch", "#10-24 UNC"), + ("hex_cap_screw_inch", "M12"), + ("hex_cap_screw_inch", "1/2-20 UNC"), + ("hex_nut_inch", "1/2"), + ("washer_sae", "9/16"), + ("washer_uss", "1/2-13 UNC"), + ] { + assert!(Session::default().execute("parts.insert", &json!({"family": family, "size": size})).is_err(), "{family} {size}"); + } + } + + #[test] + fn inch_lengths_read_as_fractions() { + assert_eq!(super::part_length_label("hex_cap_screw_inch", 1.5 * 25.4).as_deref(), Some("1-1/2 in")); + assert_eq!(super::part_length_label("hex_cap_screw_inch", 0.75 * 25.4).as_deref(), Some("3/4 in")); + assert_eq!(super::part_length_label("hex_cap_screw_inch", 8.0 * 25.4).as_deref(), Some("8 in")); + // Off the 1/64 grid, or a metric family: shown as millimetres in the design's units. + assert_eq!(super::part_length_label("hex_cap_screw_inch", 20.0), None); + assert_eq!(super::part_length_label("socket_head_cap_screw", 25.4), None); + for bad in [f64::NAN, f64::INFINITY, -25.4, 0.0, 1e300] { + assert_eq!(super::part_length_label("hex_cap_screw_inch", bad), None, "{bad}"); + } + } + /// #7692: a button head cap screw (ISO 7380-1) takes the same parameters as a socket head /// cap screw, with a domed crown in place of the cylindrical head. #[test] @@ -955,6 +1228,10 @@ mod tests { ("set_screw", "M6", "M8"), ("dowel_pin", "6", "8"), ("bearing", "608", "6200"), + ("hex_cap_screw_inch", "1/2-13 UNC", "5/8-11 UNC"), + ("hex_nut_inch", "1/2-13 UNC", "5/8-18 UNF"), + ("washer_sae", "1/2", "5/8"), + ("washer_uss", "1/2", "5/8"), ] { let mut s = Session::default(); let part = run(&mut s, "parts.insert", json!({"family": family, "size": size})); diff --git a/crates/ui-egui/src/dialogs_part_size.rs b/crates/ui-egui/src/dialogs_part_size.rs index 16d5c9ecb..2678b7643 100644 --- a/crates/ui-egui/src/dialogs_part_size.rs +++ b/crates/ui-egui/src/dialogs_part_size.rs @@ -18,12 +18,16 @@ pub(crate) fn configuration(app: &SolveApp, component: u64) -> Option { if size.is_empty() { return None; } - Some(configuration_name(size, part.length)) + Some(configuration_name(&part.family, size, part.length)) } -fn configuration_name(size: &str, length: Option) -> String { +/// An inch family's length is in fractional inches (`1/2-13 UNC×2 in`), a metric one's in mm. +fn configuration_name(family: &str, size: &str, length: Option) -> String { match length.filter(|length| length.is_finite() && *length > 0.0) { - Some(length) => format!("{size}×{length}"), + Some(length) => match solidcraft_engine::cmd::part_length_label(family, length) { + Some(label) => format!("{size}×{label}"), + None => format!("{size}×{length}"), + }, None => size.to_owned(), } } @@ -183,14 +187,14 @@ pub fn rows(app: &SolveApp, ui: &mut egui::Ui, k: &mut Resize) -> bool { choice_row(ui, "Size", "part_resize_size", &mut k.size, &sizes); if let Some(lengths) = k.lengths() { let mut index = k.length.and_then(|l| lengths.iter().position(|x| *x == l)).unwrap_or(0); - let labels: Vec = lengths.iter().map(|l| crate::prefs::show_mm(app, *l, 1)).collect(); + let labels: Vec = lengths.iter().map(|l| crate::dialogs_parts::length_label(app, &k.family.id, *l)).collect(); let labels: Vec<&str> = labels.iter().map(String::as_str).collect(); choice_row(ui, "Length", "part_resize_length", &mut index, &labels); k.length = lengths.get(index).copied(); } if let Some((size, _)) = k.family.sizes.get(k.size) { row(ui, "Configuration", |ui| { - ui.label(configuration_name(size, k.length)); + ui.label(configuration_name(&k.family.id, size, k.length)); }); } crate::ui_kit::text(ui, crate::i18n::tr("ui.part_size_shared"), crate::ui_kit::Text::Hint("part_size_shared")); @@ -479,6 +483,10 @@ mod tests { ("set_screw", "M5", Some(10.0)), ("dowel_pin", "6", Some(20.0)), ("bearing", "608", None), + ("hex_cap_screw_inch", "1/2-13 UNC", Some(2.0 * 25.4)), + ("hex_nut_inch", "1/2-13 UNC", None), + ("washer_sae", "1/2", None), + ("washer_uss", "1/2", None), ] { let (app, id) = part(family, size, length); let k = Resize::new(&app, id).unwrap(); @@ -541,6 +549,23 @@ mod tests { assert_eq!(commands[0].1["length"], 20.5); } + /// #10316: an inch part's lengths are fractional inches in a millimetre design too, and the + /// command still takes millimetres. + #[test] + fn part_size_shows_an_inch_part_in_fractional_inches() { + let (app, id) = part("hex_cap_screw_inch", "1/2-13 UNC", Some(1.5 * 25.4)); + assert_eq!(configuration(&app, id).as_deref(), Some("1/2-13 UNC×1-1/2 in")); + let mut h = crate::scenario::Harness::new(); + h.app = app; + h.app.home.open = false; + menu(&mut h.app, Target::Component { id }); + h.frames(3); + assert!(h.widget_near("1-1/2 in", "Length").is_some()); + change(&mut h.app, "5/8-11 UNC", Some(2.0 * 25.4)); + let commands = crate::dialogs::apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap(); + assert_eq!((commands[0].1["size"].as_str(), commands[0].1["length"].as_f64()), (Some("5/8-11 UNC"), Some(50.8))); + } + #[test] fn part_size_real_widgets_change_size_length_and_confirm_once() { let (app, id) = part("socket_head_cap_screw", "M5", Some(20.5)); diff --git a/crates/ui-egui/src/dialogs_parts.rs b/crates/ui-egui/src/dialogs_parts.rs index d6f0c4b59..36e6fd0d1 100644 --- a/crates/ui-egui/src/dialogs_parts.rs +++ b/crates/ui-egui/src/dialogs_parts.rs @@ -20,6 +20,8 @@ pub struct Family { pub id: String, pub name: String, pub standard: String, + /// `metric` or `inch`: the Unit system list shows the families of one at a time. + pub system: String, /// Size names and their table rows. pub sizes: Vec<(String, Value)>, pub lengths: Option>, @@ -43,6 +45,7 @@ pub fn families(v: &Value) -> Vec { Some(Family { name: f.get("name").and_then(Value::as_str).unwrap_or(&id).to_string(), standard: f.get("standard").and_then(Value::as_str).unwrap_or("").to_string(), + system: f.get("system").and_then(Value::as_str).unwrap_or("metric").to_string(), sizes, lengths: f.get("lengths").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_f64).collect()), id, @@ -61,6 +64,9 @@ pub(crate) fn family_name(f: &Family) -> String { } } +/// The Unit system list: each system's id in the library and its label. +const SYSTEMS: [(&str, &str); 2] = [("metric", "Metric"), ("inch", "Inch")]; + #[derive(Clone, Debug)] pub struct Pt { pub family: usize, @@ -120,6 +126,12 @@ pub fn insert_params(lib: &[Family], k: &Pt, holes: &[Sel]) -> Result String { + solidcraft_engine::cmd::part_length_label(family, mm).unwrap_or_else(|| crate::prefs::show_mm(app, mm, 1)) +} + /// Where the Length list opens for a size: the index of the length an insert of it gets when /// none is asked for, which `parts.library` reports beside the size's table values. The list /// carries no item of its own for it, so a size whose default is missing opens on the first. @@ -162,12 +174,34 @@ pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Pt, inputs: &[SelInpu }); return false; } - let names: Vec = - lib.iter().map(|f| if f.standard.is_empty() { family_name(f) } else { format!("{} ({})", family_name(f), f.standard) }).collect(); + // The Unit system list picks metric or inch; Type lists that system's families. The system + // shown is the chosen family's, so a new system moves the choice to its first family. + let current = lib.get(k.family).map_or("metric", |f| f.system.as_str()); + let mut system = SYSTEMS.iter().position(|s| s.0 == current).unwrap_or(0); + let was_system = system; + choice_row(ui, "Unit system", "pt_system", &mut system, &SYSTEMS.map(|s| s.1)); + let system_id = SYSTEMS.get(system).map_or("metric", |s| s.0); + if system != was_system + && let Some(first) = lib.iter().position(|f| f.system == system_id) + { + k.family = first; + k.size = 0; + k.length = None; + } + let shown: Vec = (0..lib.len()).filter(|i| lib.get(*i).is_some_and(|f| f.system == system_id)).collect(); + let names: Vec = shown + .iter() + .filter_map(|i| lib.get(*i)) + .map(|f| if f.standard.is_empty() { family_name(f) } else { format!("{} ({})", family_name(f), f.standard) }) + .collect(); let refs: Vec<&str> = names.iter().map(String::as_str).collect(); - let before = k.family; - choice_row(ui, "Type", "pt_family", &mut k.family, &refs); - if k.family != before { + let mut pick = shown.iter().position(|i| *i == k.family).unwrap_or(0); + let before = pick; + choice_row(ui, "Type", "pt_family", &mut pick, &refs); + if pick != before + && let Some(i) = shown.get(pick) + { + k.family = *i; k.size = 0; k.length = None; } @@ -180,7 +214,7 @@ pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Pt, inputs: &[SelInpu k.length = None; } if let Some(ls) = &f.lengths { - let labels: Vec = ls.iter().map(|l| crate::prefs::show_mm(app, *l, 1)).collect(); + let labels: Vec = ls.iter().map(|l| length_label(app, &f.id, *l)).collect(); let refs: Vec<&str> = labels.iter().map(String::as_str).collect(); let mut i = k.length.unwrap_or_else(|| default_length(f, k.size, ls)); form_row(ui, "Length", |ui| { @@ -302,7 +336,8 @@ mod tests { for f in &l { assert_ne!(family_name(f), f.name, "{}", f.id); } - let unknown = Family { id: "spring".into(), name: "Spring".into(), standard: String::new(), sizes: vec![], lengths: None }; + let unknown = + Family { id: "spring".into(), name: "Spring".into(), standard: String::new(), system: "metric".into(), sizes: vec![], lengths: None }; assert_eq!(family_name(&unknown), "Spring"); } @@ -339,6 +374,38 @@ mod tests { assert!(insert_params(&[], &k, &[]).is_err()); } + /// #10316: the Unit system list above Type picks metric or inch, and Type then lists that + /// system's families only. + #[test] + fn the_system_list_picks_the_families_type_shows() { + let chosen = |h: &crate::scenario::Harness| { + let Kind::Part(k) = &h.app.dialog.as_ref().unwrap().kind else { panic!("not Insert Part") }; + commands(&h.app, k, &[]).unwrap()[0].1.clone() + }; + let mut h = crate::scenario::Harness::new(); + h.app.home.open = false; + h.app.start("parts.insert"); + h.frames(3); + assert!(h.widget_near("Metric", "Unit system").is_some()); + assert_eq!(chosen(&h)["family"], "socket_head_cap_screw"); + h.step(&json!({"click":{"handle":"dialog:Unit system"}})).unwrap(); + h.step(&json!({"click":{"handle":"dialog:Unit system:Inch"}})).unwrap(); + h.frames(2); + assert_eq!((chosen(&h)["family"].as_str(), chosen(&h)["size"].as_str()), (Some("hex_cap_screw_inch"), Some("1/4-20 UNC"))); + // Type now lists the inch families and no metric one. + h.step(&json!({"click":{"handle":"dialog:Type"}})).unwrap(); + assert!(crate::scenario::handle_at("dialog:Type:Plain washer, USS (wide) (ANSI B18.22.1 Type A)").is_some()); + assert!(crate::scenario::handle_at("dialog:Type:Hex nut (ISO 4032)").is_none()); + h.step(&json!({"click":{"handle":"dialog:Type:Hex nut (inch) (ASME B18.2.2)"}})).unwrap(); + h.frames(2); + assert_eq!(chosen(&h)["family"], "hex_nut_inch"); + // Back to metric: the first metric family again. + h.step(&json!({"click":{"handle":"dialog:Unit system"}})).unwrap(); + h.step(&json!({"click":{"handle":"dialog:Unit system:Metric"}})).unwrap(); + h.frames(2); + assert_eq!(chosen(&h)["family"], "socket_head_cap_screw"); + } + /// Every dimension the library gives for a size is labelled in words, in each family. #[test] fn every_library_dimension_has_a_label_in_words() {