Insert Part: ASME/ANSI inch hex cap screws, hex nuts and SAE/USS washers (#10316) (#10335)

* claim: #10316

* Insert Part: ASME/ANSI inch hex cap screws, hex nuts and SAE/USS washers (#10316)

Part of #10316. New standard-part families, tabled in inches as the
standards give them and built in millimetres: hex cap screw (ASME
B18.2.1) and hex nut (ASME B18.2.2), 1/4 to 1 in UNC and UNF from the
thread catalogue, and plain washers SAE and USS (ANSI B18.22.1 Type A).
Cap screws take the standard inch lengths, 1/2 to 8 in, defaulting to
the first at or above 2.5 d.

Lengths read as fractional inches in Insert Part, Change Part Size, part
names and part numbers. Insert Part gains a Unit system list (Metric,
Inch) above Type; it opens on Metric. parts.library reports each
family's system.

Inch parts get no cosmetic thread: solid.thread takes only metric
designations (#9571), and the old path would have made a wrong metric
mark. 9/16 waits for the thread catalogue; split lock washers and
carriage bolts follow in later PRs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Daniel Katz
2026-11-02 00:21:21 +00:00
committed by GitHub
parent a22ea76ab6
commit 3231f049d0
5 changed files with 491 additions and 38 deletions
@@ -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"
}
}
+1
View File
@@ -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::{
+303 -26
View File
@@ -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<f64> {
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<solidcraft_doc::TappedThread> {
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<String> {
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<String> {
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<f64>, 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<f64>, 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<f64>) -> std::result::Result<S
"socket_head_cap_screw" => {
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<Value> {
"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<Value> {
}
}
}
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<Value> {
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<f64> = 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}));
+30 -5
View File
@@ -18,12 +18,16 @@ pub(crate) fn configuration(app: &SolveApp, component: u64) -> Option<String> {
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<f64>) -> 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<f64>) -> 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<String> = lengths.iter().map(|l| crate::prefs::show_mm(app, *l, 1)).collect();
let labels: Vec<String> = 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));
+74 -7
View File
@@ -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<Vec<f64>>,
@@ -43,6 +45,7 @@ pub fn families(v: &Value) -> Vec<Family> {
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<Value, Str
Ok(p)
}
/// A length (mm) of a part of the family: in fractional inches for an inch family, in the
/// design's units otherwise.
pub(crate) fn length_label(app: &SolveApp, family: &str, mm: f64) -> 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<String> =
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<usize> = (0..lib.len()).filter(|i| lib.get(*i).is_some_and(|f| f.system == system_id)).collect();
let names: Vec<String> = 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<String> = ls.iter().map(|l| crate::prefs::show_mm(app, *l, 1)).collect();
let labels: Vec<String> = 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() {