* claim: #4414 * feat: persist right and left thread handedness (#4414) * fix(thread): verify handedness with referenced holes and complete locales * test: verify handedness with merged tapped thread catalogues * test: retain tapped thread depth when changing handedness (#4414) * test: restrict Unix symlink coverage to Unix targets * test: inspect hole thread depth inside edit command parameters (#4414) * test(doc): initialize cylinder radius in handedness fixture
725 lines
39 KiB
Rust
725 lines
39 KiB
Rust
//! Modelled threads: the ISO metric profile cut along a helix, inside and outside,
|
||
//! including fine pitches on large shafts and the sample flange.
|
||
|
||
use std::f64::consts::PI;
|
||
|
||
use serde_json::{Value, json};
|
||
use solidcraft_geom::Vec3;
|
||
|
||
use crate::Session;
|
||
|
||
fn run(s: &mut Session, id: &str, p: Value) -> Value {
|
||
match s.execute(id, &p) {
|
||
Ok(v) => v,
|
||
Err(e) => panic!("{id} {p}: {e}"),
|
||
}
|
||
}
|
||
|
||
/// Volume from the body's mesh: exact for the faceted threaded body, and quicker than a full
|
||
/// measurement of its thousands of faces.
|
||
fn volume(s: &mut Session, b: &str) -> f64 {
|
||
let st = s.model.state();
|
||
st.body(b).map(|mb| mb.body.tessellate(1e-3).unwrap().measure().volume).unwrap_or(0.0)
|
||
}
|
||
|
||
const SIZES: [(f64, f64); 9] = [(3.0, 0.5), (4.0, 0.7), (5.0, 0.8), (6.0, 1.0), (8.0, 1.25), (10.0, 1.5), (12.0, 1.75), (16.0, 2.0), (20.0, 2.5)];
|
||
|
||
fn assert_tapped_depth(state: &solidcraft_doc::ModelState, entry: Vec3, inward: Vec3, offset: f64, depth: f64) {
|
||
assert_eq!(state.threads.len(), 1);
|
||
let thread = &state.threads[0];
|
||
assert!(thread.internal);
|
||
let a = (thread.axis_point + thread.axis * thread.start - entry).dot(inward);
|
||
let b = (thread.axis_point + thread.axis * thread.end - entry).dot(inward);
|
||
assert!((a.min(b) - offset).abs() < 1e-6, "thread entry {} mm, expected {offset} mm", a.min(b));
|
||
assert!((a.max(b) - offset - depth).abs() < 1e-6, "thread end {} mm, expected {} mm", a.max(b), offset + depth);
|
||
}
|
||
|
||
#[test]
|
||
fn tapped_thread_depth_keeps_reference_edge_placement_after_reopen() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.box", json!({"length":60,"width":60,"height":12}));
|
||
run(
|
||
&mut s,
|
||
"solid.hole",
|
||
json!({"position":[30,30,12],"thread":"M6","depth":8,"thread_depth":3,
|
||
"references":[{"edge":[0,25,12],"distance":"10 mm"},{"edge":[25,0,12],"distance":"12 mm"}]}),
|
||
);
|
||
let inward = Vec3::new(0.0, 0.0, -1.0);
|
||
let entry = Vec3::new(10.0, 12.0, 12.0);
|
||
assert_tapped_depth(&s.model.state(), entry, inward, 0.0, 3.0);
|
||
let reopened = Session::new(solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap());
|
||
assert_tapped_depth(&reopened.model.state(), entry, inward, 0.0, 3.0);
|
||
let solidcraft_doc::FeatureKind::Hole { references, thread_depth, .. } = &reopened.doc.features.last().unwrap().kind else {
|
||
panic!("expected a referenced tapped hole");
|
||
};
|
||
assert_eq!(references.len(), 2);
|
||
assert_eq!(thread_depth.as_ref().unwrap().to_string(), "3");
|
||
assert!(!reopened.model.state().bodies[0].body.contains(Vec3::new(10.0, 12.0, 10.0)));
|
||
}
|
||
|
||
#[test]
|
||
fn tapped_thread_depth_is_independent_through_preview_redefine_undo_and_reload() {
|
||
for (height, mut params, full) in
|
||
[(12.0, json!({"depth":8,"type":"drilled"}), 8.0), (12.0, json!({}), 12.0), (12.0, json!({"to":[30,30,5]}), 7.0)]
|
||
{
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.box", json!({"length":60,"width":60,"height":height,"body_name":"Plate"}));
|
||
params["position"] = json!([30, 30, height]);
|
||
params["direction"] = json!([0, 0, -1]);
|
||
params["thread"] = json!("M6");
|
||
let hole = run(&mut s, "solid.hole", params.clone())["feature"].as_u64().unwrap();
|
||
let entry = Vec3::new(30.0, 30.0, height);
|
||
let inward = Vec3::new(0.0, 0.0, -1.0);
|
||
assert_tapped_depth(&s.model.state(), entry, inward, 0.0, full);
|
||
let before = s.doc.to_json();
|
||
let physical_volume = volume(&mut s, "Plate");
|
||
|
||
// Version 29 never saved this field: its default remains the full wall.
|
||
let mut legacy: Value = serde_json::from_str(&before).unwrap();
|
||
legacy["format"] = json!("solidcraft/29");
|
||
let reopened = Session::new(solidcraft_doc::Document::from_json(&legacy.to_string()).unwrap());
|
||
assert_tapped_depth(&reopened.model.state(), entry, inward, 0.0, full);
|
||
|
||
params["thread_depth"] = json!(4);
|
||
let redefine = json!({"feature":hole,"command":"solid.hole","params":params});
|
||
let preview = s.preview(&[("timeline.redefine".into(), redefine.clone())]).unwrap();
|
||
assert_tapped_depth(&preview.after, entry, inward, 0.0, 4.0);
|
||
assert_eq!(s.doc.to_json(), before, "preview must not change the design");
|
||
run(&mut s, "timeline.redefine", redefine);
|
||
assert_tapped_depth(&s.model.state(), entry, inward, 0.0, 4.0);
|
||
assert!((volume(&mut s, "Plate") - physical_volume).abs() < 1e-6, "thread depth must not change the drill geometry");
|
||
let saved = s.doc.to_json();
|
||
let reopened = Session::new(solidcraft_doc::Document::from_json(&saved).unwrap());
|
||
assert_tapped_depth(&reopened.model.state(), entry, inward, 0.0, 4.0);
|
||
run(&mut s, "edit.undo", json!({}));
|
||
assert_eq!(s.doc.to_json(), before);
|
||
assert_tapped_depth(&s.model.state(), entry, inward, 0.0, full);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn tapped_thread_depth_uses_the_cylinder_beyond_recesses_and_in_shallow_holes() {
|
||
for (height, mut params, offset, full) in [
|
||
(12.0, json!({"thread":"M6","type":"counterbore","cb_diameter":12,"cb_depth":5,"depth":9}), 5.0, 4.0),
|
||
(12.0, json!({"thread":"G 1/4","type":"counterbore","cb_diameter":20,"cb_depth":5,"depth":9}), 5.0, 4.0),
|
||
(12.0, json!({"thread":"1/4-20 UNC","type":"counterbore","cb_diameter":12,"cb_depth":5,"depth":9}), 5.0, 4.0),
|
||
(12.0, json!({"thread":"M6","type":"countersink","cs_diameter":11,"cs_angle":"90 deg","depth":9}), 3.0, 6.0),
|
||
(12.0, json!({"thread":"M36","type":"drilled","depth":3}), 0.0, 3.0),
|
||
(5.0, json!({"thread":"M36"}), 0.0, 5.0),
|
||
] {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.box", json!({"length":60,"width":60,"height":height,"body_name":"Plate"}));
|
||
params["position"] = json!([30, 30, height]);
|
||
params["direction"] = json!([0, 0, -1]);
|
||
let hole = run(&mut s, "solid.hole", params.clone())["feature"].as_u64().unwrap();
|
||
let entry = Vec3::new(30.0, 30.0, height);
|
||
let inward = Vec3::new(0.0, 0.0, -1.0);
|
||
assert_tapped_depth(&s.model.state(), entry, inward, offset, full);
|
||
params["thread_depth"] = json!(2);
|
||
run(&mut s, "timeline.redefine", json!({"feature":hole,"command":"solid.hole","params":params}));
|
||
assert_tapped_depth(&s.model.state(), entry, inward, offset, 2.0);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn tapped_thread_depth_starts_at_the_entry_for_both_axis_directions() {
|
||
for (entry, inward) in [(Vec3::new(0.0, 10.0, 6.0), Vec3::new(1.0, 0.0, 0.0)), (Vec3::new(20.0, 10.0, 6.0), Vec3::new(-1.0, 0.0, 0.0))] {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.box", json!({"length":20,"width":20,"height":12}));
|
||
run(
|
||
&mut s,
|
||
"solid.hole",
|
||
json!({"position":[entry.x,entry.y,entry.z],"direction":[inward.x,inward.y,inward.z],"thread":"M6","depth":8,"thread_depth":3}),
|
||
);
|
||
assert_tapped_depth(&s.model.state(), entry, inward, 0.0, 3.0);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn tapped_thread_depth_rejects_invalid_or_excessive_values_atomically() {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.box", json!({"length":20,"width":20,"height":10}));
|
||
let before = s.doc.to_json();
|
||
for depth in [json!(0), json!(-1), json!(20), json!(true), json!(""), json!("NaN mm"), json!("1e999 mm"), json!("3 deg")] {
|
||
let result = s.execute("solid.hole", &json!({"position":[10,10,10],"thread":"M6","depth":8,"thread_depth":depth}));
|
||
assert!(result.is_err(), "invalid thread depth {depth}: {result:?}");
|
||
assert_eq!(s.doc.to_json(), before);
|
||
assert!(s.model.state().threads.is_empty());
|
||
}
|
||
assert!(s.execute("solid.hole", &json!({"position":[10,10,10],"diameter":5,"thread_depth":3})).is_err());
|
||
assert_eq!(s.doc.to_json(), before);
|
||
}
|
||
|
||
#[test]
|
||
fn thread_handedness_cosmetic_defaults_and_save_reopen_keep_axis_and_extent() {
|
||
use solidcraft_doc::{Document, FeatureKind, ThreadHandedness};
|
||
for (hole, designation) in [(false, "M6"), (true, "M6"), (true, "G 1/4"), (true, "1/4-20 UNC")] {
|
||
let mut reference = None;
|
||
for hand in [None, Some("right"), Some("left")] {
|
||
let mut s = Session::default();
|
||
let (command, mut params) = if hole {
|
||
run(&mut s, "solid.box", json!({"length":20,"width":20,"height":10}));
|
||
(
|
||
"solid.hole",
|
||
json!({"position":[10,10,10],"thread":designation,"depth":6,"thread_depth":3,
|
||
"references":[{"edge":[0,10,10],"distance":"7 mm"},{"edge":[10,0,10],"distance":"8 mm"}]}),
|
||
)
|
||
} else {
|
||
run(&mut s, "solid.cylinder", json!({"radius":3,"height":6}));
|
||
("solid.thread", json!({"face":[3,0,2],"designation":"M6","length":4}))
|
||
};
|
||
if let Some(hand) = hand {
|
||
params["handedness"] = json!(hand);
|
||
}
|
||
run(&mut s, command, params);
|
||
let expected = if hand == Some("left") { ThreadHandedness::Left } else { ThreadHandedness::Right };
|
||
let info = s.model.state().threads[0].clone();
|
||
assert_eq!(info.handedness, expected);
|
||
if hole {
|
||
assert!((info.end - info.start - 3.0).abs() < 1e-8, "direction must retain the independent thread depth");
|
||
}
|
||
let dimensions = (info.axis_point, info.axis, info.start, info.end, info.major_diameter, info.pitch);
|
||
assert_eq!(*reference.get_or_insert(dimensions), dimensions, "direction must not change axis, length or size");
|
||
let mut kind = serde_json::to_value(&s.doc.features.last().unwrap().kind).unwrap();
|
||
assert_eq!(kind.get("handedness"), (expected == ThreadHandedness::Left).then(|| json!("left")).as_ref());
|
||
// An old feature with no field still deserializes to Right, for both feature types.
|
||
kind.as_object_mut().unwrap().remove("handedness");
|
||
let old: FeatureKind = serde_json::from_value(kind).unwrap();
|
||
assert!(matches!(
|
||
old,
|
||
FeatureKind::Hole { handedness: ThreadHandedness::Right, .. } | FeatureKind::Thread { handedness: ThreadHandedness::Right, .. }
|
||
));
|
||
let reopened = Session::new(Document::from_json(&s.doc.to_json()).unwrap());
|
||
assert_eq!(reopened.model.state().threads[0], info);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn thread_handedness_invalid_values_fail_without_changing_the_document() {
|
||
for hole in [false, true] {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.cylinder", json!({"radius":3,"height":6}));
|
||
let saved = s.doc.to_json();
|
||
for hand in [json!("clockwise"), json!("LEFT"), json!(null), json!(true), json!(1)] {
|
||
let (command, params) = if hole {
|
||
("solid.hole", json!({"position":[0,0,6],"thread":"M6","handedness":hand}))
|
||
} else {
|
||
("solid.thread", json!({"face":[3,0,2],"designation":"M6","handedness":hand}))
|
||
};
|
||
assert!(s.execute(command, ¶ms).unwrap_err().to_string().contains("handedness"));
|
||
assert_eq!(s.doc.to_json(), saved);
|
||
}
|
||
if hole {
|
||
assert!(s.execute("solid.hole", &json!({"position":[0,0,6],"diameter":2,"handedness":"left"})).is_err());
|
||
assert_eq!(s.doc.to_json(), saved);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn thread_handedness_modelled_internal_and_external_keep_chirality_and_bounded_volume() {
|
||
use solidcraft_doc::Document;
|
||
for internal in [false, true] {
|
||
let mut bodies = Vec::new();
|
||
for hand in ["right", "left"] {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.cylinder", json!({"radius":if internal {6.0} else {3.0},"height":4,"body_name":"Stock"}));
|
||
if internal {
|
||
run(&mut s, "solid.hole", json!({"position":[0,0,4],"diameter":5}));
|
||
}
|
||
let face = json!([if internal { 2.5 } else { 3.0 }, 0, 3.5]);
|
||
run(&mut s, "solid.thread", json!({"face":face,"designation":"M6x1","length":3,"modeled":true,"handedness":hand}));
|
||
let state = s.model.state();
|
||
let body = state.body("Stock").unwrap().body.clone();
|
||
assert!(body.validity().is_empty(), "{internal}/{hand}: {:?}", body.validity());
|
||
let before = volume(&mut s, "Stock");
|
||
let mut reopened = Session::new(Document::from_json(&s.doc.to_json()).unwrap());
|
||
assert!((volume(&mut reopened, "Stock") - before).abs() < 1e-8);
|
||
let brep_volume = crate::kernel::measure(&body).unwrap().volume;
|
||
bodies.push((body, before, brep_volume));
|
||
}
|
||
let [(right, vr, br), (left, vl, bl)] = bodies.as_slice() else { panic!("two directions") };
|
||
eprintln!("handedness internal={internal}: mesh_mm3={vr}/{vl}, brep_mm3={br}/{bl}");
|
||
for body in [right, left] {
|
||
let mesh = body.tessellate(0.001).unwrap();
|
||
let low = mesh.positions.iter().map(|p| p.z).fold(f64::INFINITY, f64::min);
|
||
let high = mesh.positions.iter().map(|p| p.z).fold(f64::NEG_INFINITY, f64::max);
|
||
assert!(low.abs() < 1e-8 && (high - 4.0).abs() < 1e-8, "physical axial bounds: {low}/{high}");
|
||
for z in [0.25, 1.5, 2.5, 3.75] {
|
||
assert_eq!(body.contains(Vec3::new(0.0, 0.0, z)), !internal, "axis stays solid in a shaft and open in a bore");
|
||
if internal {
|
||
for i in 0..24 {
|
||
let a = 2.0 * PI * i as f64 / 24.0;
|
||
assert!(body.contains(Vec3::new(4.5 * a.cos(), 4.5 * a.sin(), z)), "the outer wall remains whole");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let radius = if internal { 2.75 } else { 2.65 };
|
||
let mut different = 0;
|
||
for z in [0.4, 1.1, 1.4, 1.8, 2.2, 2.6, 3.1, 3.5] {
|
||
for i in 0..24 {
|
||
let angle = 2.0 * PI * (i as f64 + 0.17) / 24.0;
|
||
let p = Vec3::new(radius * angle.cos(), radius * angle.sin(), z);
|
||
let reflected = Vec3::new(-p.x, p.y, p.z);
|
||
assert_eq!(right.contains(p), left.contains(reflected), "actual mirrored helix: {internal} at {p:?}");
|
||
different += usize::from(right.contains(p) != left.contains(p));
|
||
if z < 1.0 {
|
||
assert!(right.contains(p), "the 3 mm thread must leave the lower stub unchanged");
|
||
}
|
||
}
|
||
}
|
||
assert!(different > 20, "Left must change real geometry, not just metadata: {internal}: {different}");
|
||
// The sweep itself is an exact reflection (doc test). The existing Boolean first
|
||
// facets the curved stock within pitch * .005 mm. A nominal stock-faceting
|
||
// regression envelope uses radial annuli [r-d, r+d], with flat caps unchanged:
|
||
// pi*h*((r+d)^2-(r-d)^2) = 4*pi*h*r*d, summed over the outer and bore cylinders.
|
||
// Exact-set cutting would not enlarge the stock's symmetric difference. The BSP
|
||
// and rebuild also use numerical epsilons, so this conservative secondary ceiling
|
||
// is not a rigorous bound on every Boolean error, nor a precision/equal-volume proof.
|
||
let delta = 1.0 * 0.005;
|
||
let radii = if internal { 6.0 + 2.5 } else { 3.0 };
|
||
let budget = 4.0 * PI * 4.0 * radii * delta;
|
||
eprintln!(
|
||
"handedness internal={internal}: post_boolean_delta_mm3={}, stock_faceting_budget_mm3={budget}, relative_delta={}",
|
||
(br - bl).abs(),
|
||
(br - bl).abs() / br
|
||
);
|
||
assert!(
|
||
(br - bl).abs() <= budget,
|
||
"post-Boolean volume exceeds the configured stock faceting envelope: {internal}: {br}/{bl}, budget {budget}"
|
||
);
|
||
}
|
||
}
|
||
|
||
/// Keep the original 48-station reproduction of the shell error even though new fine
|
||
/// threads now use more stations. The same cut polygons must rebuild as a closed solid.
|
||
#[test]
|
||
fn faceted_flange_thread_preserves_thin_crest_boundaries() {
|
||
use crate::geom::{Plane, Vec2, Vec3};
|
||
use crate::kernel;
|
||
|
||
let mut s = Session::default();
|
||
let sample = crate::sample::samples().into_iter().find(|s| s.name == "Bolted Flange").unwrap();
|
||
s.run_script(&(sample.script)()).unwrap();
|
||
let state = s.model.state();
|
||
let body = &state.body("Flange").unwrap().body;
|
||
let face = Vec3::new(-19.034766861657907, -11.03075929038123, 19.574640342897094);
|
||
let cylinder = kernel::cylinder_face_at(body, face).unwrap();
|
||
let pitch = 1.5;
|
||
let height = pitch * 3f64.sqrt() / 2.0;
|
||
let root = 22.0 - 5.0 * height / 8.0;
|
||
let outer = 22.0 + 0.05 * pitch;
|
||
let half_width = (pitch / 4.0 + 2.0 * (outer - root) * (PI / 6.0).tan()) / 2.0;
|
||
let section = [Vec2::new(root, -pitch / 8.0), Vec2::new(outer, -half_width), Vec2::new(outer, half_width), Vec2::new(root, pitch / 8.0)];
|
||
let (start, end) = (cylinder.start - pitch, cylinder.end + pitch);
|
||
let base = cylinder.axis_point + cylinder.axis * start;
|
||
let plane = Plane { origin: base, x: cylinder.axis.cross(Vec3::new(1.0, 0.0, 0.0)).normalized().unwrap(), y: *cylinder.axis };
|
||
let groove = kernel::sweep_helix_mesh(&plane, §ion, base, *cylinder.axis, pitch, (end - start) / pitch, 48).unwrap();
|
||
let cut = kernel::faceted_boolean(body, &groove, kernel::BoolOp::Cut, pitch * 0.005).unwrap().unwrap();
|
||
assert!(cut.validity().is_empty(), "{:?}", cut.validity());
|
||
let before = body.tessellate(0.001).unwrap().measure().volume;
|
||
let after = cut.tessellate(0.001).unwrap().measure().volume;
|
||
assert!(before - after > 700.0 && before - after < 1800.0, "removed {}", before - after);
|
||
}
|
||
|
||
#[test]
|
||
fn modelled_full_length_m44_flange_thread() {
|
||
let mut s = Session::default();
|
||
let sample = crate::sample::samples().into_iter().find(|s| s.name == "Bolted Flange").unwrap();
|
||
s.run_script(&(sample.script)()).unwrap();
|
||
let before = volume(&mut s, "Flange");
|
||
run(
|
||
&mut s,
|
||
"solid.thread",
|
||
json!({
|
||
"face": [-19.034766861657907, -11.03075929038123, 19.574640342897094],
|
||
"designation": "M44x1.5", "modeled": true
|
||
}),
|
||
);
|
||
let state = s.model.state();
|
||
let body = &state.body("Flange").unwrap().body;
|
||
assert!(body.validity().is_empty(), "{:?}", body.validity());
|
||
let removed = before - volume(&mut s, "Flange");
|
||
assert!(removed > 700.0 && removed < 1800.0, "a full-length helical cut removes material: {removed}");
|
||
}
|
||
|
||
#[test]
|
||
fn modelled_full_length_fine_threads_on_large_shafts() {
|
||
for (d, p, len) in [(44.0, 1.0, 5.0), (44.0, 1.5, 16.0), (100.0, 1.5, 6.0)] {
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.cylinder", json!({"radius":d / 2.0,"height":len,"body_name":"Shaft"}));
|
||
let before = volume(&mut s, "Shaft");
|
||
run(&mut s, "solid.thread", json!({"face":[d / 2.0,0,len / 2.0],"designation":format!("M{d}x{p}"),"modeled":true}));
|
||
let state = s.model.state();
|
||
let body = &state.body("Shaft").unwrap().body;
|
||
assert!(body.validity().is_empty(), "M{d}x{p}: {:?}", body.validity());
|
||
let root = d / 2.0 - 5.0 * p * 3f64.sqrt() / 16.0;
|
||
let want = per_turn(root, d / 2.0, |r| p / 4.0 + 2.0 * (r - root) * (PI / 6.0).tan()) * len / p;
|
||
let got = before - volume(&mut s, "Shaft");
|
||
assert!((got - want).abs() < want * 0.04, "M{d}x{p}: removed {got}, ISO profile {want}");
|
||
}
|
||
}
|
||
|
||
/// 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 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();
|
||
run(&mut s, "solid.cylinder", json!({"radius":4,"height":10}));
|
||
let saved = s.doc.to_json();
|
||
for designation in ["Minfx1", "M8xinf", "MNaNx1", "M8xNaN", "M1e999x1"] {
|
||
let result = s.execute("solid.thread", &json!({"face":[4,0,2],"designation":designation}));
|
||
assert!(result.is_err(), "{designation}: {result:?}");
|
||
assert_eq!(s.doc.to_json(), saved);
|
||
}
|
||
}
|
||
|
||
/// ∫ 2π r · width(r) dr over [a, b]: the volume one turn of the groove takes out (a screw
|
||
/// motion of a section in an axial plane sweeps 2π∫r dA per turn).
|
||
fn per_turn(a: f64, b: f64, width: impl Fn(f64) -> f64) -> f64 {
|
||
let n = 400;
|
||
(0..n).map(|i| a + (b - a) * (i as f64 + 0.5) / n as f64).map(|r| 2.0 * PI * r * width(r) * (b - a) / n as f64).sum()
|
||
}
|
||
|
||
#[test]
|
||
fn modelled_external_threads_m3_to_m20() {
|
||
let h = |p: f64| p * 3f64.sqrt() / 2.0;
|
||
let slope = (PI / 6.0).tan();
|
||
for (d, p) in SIZES {
|
||
let mut s = Session::default();
|
||
let len = 4.0 * p;
|
||
run(&mut s, "solid.cylinder", json!({"radius": d / 2.0, "height": len + 2.0, "body_name": "Shaft"}));
|
||
let before = volume(&mut s, "Shaft");
|
||
let th = run(&mut s, "solid.thread", json!({"face": [d / 2.0, 0, 1], "length": len, "modeled": true}));
|
||
assert!(th["thread"].is_null(), "a modelled thread is real geometry, not an annotation: {th}");
|
||
let r_root = d / 2.0 - 5.0 * h(p) / 8.0;
|
||
let want = per_turn(r_root, d / 2.0, |r| p / 4.0 + 2.0 * (r - r_root) * slope) * len / p;
|
||
let got = before - volume(&mut s, "Shaft");
|
||
assert!((got - want).abs() < want * 0.03, "M{d}: removed {got}, ISO profile {want}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn modelled_internal_threads_m3_to_m20() {
|
||
let h = |p: f64| p * 3f64.sqrt() / 2.0;
|
||
let slope = (PI / 6.0).tan();
|
||
for (d, p) in SIZES {
|
||
let mut s = Session::default();
|
||
let len = 4.0 * p;
|
||
let d1 = d - 2.0 * 5.0 * h(p) / 8.0;
|
||
run(&mut s, "solid.box", json!({"corner": [-d, -d, 0], "length": 2.0 * d, "width": 2.0 * d, "height": len, "body_name": "Nut"}));
|
||
run(&mut s, "solid.cylinder", json!({"base": [0, 0, -1], "radius": d1 / 2.0, "height": len + 2.0, "body_name": "Bore"}));
|
||
run(&mut s, "solid.combine", json!({"target": "Nut", "tools": ["Bore"], "operation": "cut"}));
|
||
let before = volume(&mut s, "Nut");
|
||
let th = run(&mut s, "solid.thread", json!({"face": [d1 / 2.0, 0, len / 2.0], "modeled": true}));
|
||
assert!(th["thread"].is_null(), "{th}");
|
||
// Bolt-shaped space: P/8 flat at the major diameter, widening towards the bore.
|
||
let want = per_turn(d1 / 2.0, d / 2.0, |r| p / 8.0 + 2.0 * (d / 2.0 - r) * slope) * len / p;
|
||
let got = before - volume(&mut s, "Nut");
|
||
assert!((got - want).abs() < want * 0.03, "M{d}: removed {got}, ISO profile {want}");
|
||
}
|
||
}
|
||
|
||
/// Issue 995: an M5 modelled thread in a 5 mm hole cut nothing (the groove lay in the hole, from
|
||
/// the minor diameter out to the 5 mm major one) and only left the wall faceted. A modelled thread
|
||
/// that would cut next to nothing is refused, with the drill to use and the size that fits;
|
||
/// a cosmetic one is still only a note.
|
||
#[test]
|
||
fn a_modelled_thread_that_would_cut_nothing_is_refused() {
|
||
let mut s = hex_nut(5.0);
|
||
let before = volume(&mut s, "Nut");
|
||
let e = s.execute("solid.thread", &json!({"face": [2.5, 0, 2], "designation": "M5", "modeled": true})).err().map(|e| e.to_string());
|
||
let e = e.unwrap_or_default();
|
||
assert!(e.contains("this 5 mm hole") && e.contains("drill 4.2 mm for M5") && e.contains("thread this hole M6"), "{e}");
|
||
assert!((volume(&mut s, "Nut") - before).abs() < 1e-9);
|
||
run(&mut s, "solid.thread", json!({"face": [2.5, 0, 2], "designation": "M5"}));
|
||
|
||
// A shaft no thicker than the thread's root (17.29 mm for M20) is refused the same way.
|
||
let mut s = Session::default();
|
||
run(&mut s, "solid.cylinder", json!({"radius": 8.6, "height": 10, "body_name": "Shaft"}));
|
||
let e = s.execute("solid.thread", &json!({"face": [8.6, 0, 5], "designation": "M20", "modeled": true})).err().map(|e| e.to_string());
|
||
let e = e.unwrap_or_default();
|
||
assert!(e.contains("this 17.2 mm shaft") && e.contains("make the shaft 20 mm for M20") && e.contains("thread this shaft M18"), "{e}");
|
||
}
|
||
|
||
/// 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. (A shaft too thick is turned down.)
|
||
#[test]
|
||
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());
|
||
let e = e.unwrap_or_default();
|
||
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);
|
||
}
|
||
|
||
/// The limit is a quarter of the basic depth 5H/8: a hole up to 4.78 mm for M5 (4.86 mm for
|
||
/// M5x0.5) still takes a modelled thread, a wider one is refused with that pitch's drill.
|
||
#[test]
|
||
fn the_cut_nothing_limit_holds_for_coarse_and_fine_pitch() {
|
||
for (m, hole, refused) in [
|
||
("M5", 4.5, None),
|
||
("M5", 4.75, None),
|
||
("M5", 4.8, Some("drill 4.2 mm for M5, or thread this hole M6")),
|
||
("M5x0.5", 4.5, None),
|
||
("M5x0.5", 4.85, None),
|
||
("M5x0.5", 4.9, Some("drill 4.5 mm for M5x0.5, or thread this hole M6")),
|
||
("M5x0.5", 5.0, Some("drill 4.5 mm for M5x0.5, or thread this hole M6")),
|
||
] {
|
||
let mut s = hex_nut(hole);
|
||
let before = volume(&mut s, "Nut");
|
||
let made = s.execute("solid.thread", &json!({"face": [hole / 2.0, 0, 2], "designation": m, "modeled": true}));
|
||
let cut = before - volume(&mut s, "Nut");
|
||
match (refused, made) {
|
||
(None, Ok(_)) => assert!(cut > 0.05, "{m} in {hole} mm: removed {cut}"),
|
||
(Some(want), Err(e)) => {
|
||
let e = e.to_string();
|
||
assert!(e.contains(&format!("this {hole} mm hole")) && e.contains(want), "{m} in {hole} mm: {e}");
|
||
assert!(cut.abs() < 1e-9, "{m} in {hole} mm: removed {cut}");
|
||
}
|
||
(want, got) => panic!("{m} in {hole} mm: want refused {want:?}, got {:?}", got.map(|_| ())),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// A 4 mm hex nut (inscribed radius 5) with a plain hole of this diameter through it.
|
||
fn hex_nut(hole: f64) -> Session {
|
||
let mut s = Session::default();
|
||
for (id, p) in [
|
||
("sketch.create", json!({"plane": "XY"})),
|
||
("sketch.polygon.inscribed", json!({"center": [0, 0], "radius": 5, "sides": 6})),
|
||
("sketch.finish", json!({})),
|
||
("solid.extrude", json!({"distance": 4, "body_name": "Nut"})),
|
||
("solid.hole", json!({"position": [0, 0, 4], "diameter": hole})),
|
||
] {
|
||
run(&mut s, id, p);
|
||
}
|
||
s
|
||
}
|
||
|
||
/// A screw with a modeled M5 thread of `length` millimetres: the number of faces the thread left
|
||
/// on it, and how long the fillet of the boss's top edges took. The fillet is the work under test:
|
||
/// it healed the thread's facets and compared each of them with the whole old body, which froze
|
||
/// the app for minutes (#602).
|
||
fn fillet_beside_a_thread(length: f64) -> (usize, std::time::Duration) {
|
||
let mut s = Session::default();
|
||
for (id, p) in [
|
||
("sketch.create", json!({"plane": "XY"})),
|
||
("sketch.circle.center", json!({"center": [0, 0], "diameter": 5})),
|
||
("sketch.finish", json!({})),
|
||
("solid.extrude", json!({"distance": 10, "body_name": "Screw"})),
|
||
("sketch.create", json!({"plane": {"face": [0, 0, 10]}})),
|
||
("sketch.polygon.circumscribed", json!({"center": [0, 0], "radius": 2, "sides": 6})),
|
||
("sketch.finish", json!({})),
|
||
("solid.extrude", json!({"distance": 3, "profiles": [{"point": [0, 0]}], "operation": "join", "targets": ["Screw"]})),
|
||
("solid.thread", json!({"face": [2.5, 0, 5], "designation": "M5", "length": length, "modeled": true})),
|
||
] {
|
||
run(&mut s, id, p);
|
||
}
|
||
let faces = s.model.state().body("Screw").map(|b| b.body.face_count()).unwrap_or(0);
|
||
let volume_before = volume(&mut s, "Screw");
|
||
let top: Vec<Value> = (0..6)
|
||
.map(|i| {
|
||
let a = (30.0 + 60.0 * i as f64).to_radians();
|
||
json!([2.0 * a.cos(), 2.0 * a.sin(), 13])
|
||
})
|
||
.collect();
|
||
let started = std::time::Instant::now();
|
||
run(&mut s, "solid.fillet", json!({"edges": top, "radius": 0.3}));
|
||
let took = started.elapsed();
|
||
let volume_after = volume(&mut s, "Screw");
|
||
assert!(volume_after < volume_before && volume_after > volume_before * 0.99, "{volume_before} -> {volume_after}");
|
||
(faces, took)
|
||
}
|
||
|
||
/// Whether a job several times the size took at most about linear: `pair` times the small job,
|
||
/// then the big one. The quadratic that the bug cost grows with the square of the work, so eight
|
||
/// times the small time is the limit. The load of the other test binaries can rise between the two
|
||
/// runs, so a pair that misses is measured again, up to three times. Load only ever slows a run,
|
||
/// so each size keeps its fastest time and the ratio is taken of those: a retry cannot pass a
|
||
/// regression on a small run that a spike happened to slow, once an earlier small run was fast.
|
||
///
|
||
/// `slack` is the room the noise of a busy machine gets, on top of the ratio.
|
||
fn scales_linearly(mut pair: impl FnMut() -> (std::time::Duration, std::time::Duration), slack: std::time::Duration) -> Result<(), String> {
|
||
let limit = |small: f64| 8.0 * small + slack.as_secs_f64();
|
||
let (mut small, mut big) = (f64::INFINITY, f64::INFINITY);
|
||
let mut runs = Vec::new();
|
||
for _ in 0..3 {
|
||
let (s, b) = pair();
|
||
small = small.min(s.as_secs_f64());
|
||
big = big.min(b.as_secs_f64());
|
||
runs.push(format!("{s:?} then {b:?}"));
|
||
if big < limit(small) {
|
||
return Ok(());
|
||
}
|
||
}
|
||
Err(format!("{}; fastest {small:.3} s and {big:.3} s, limit {:.3} s", runs.join(", "), limit(small)))
|
||
}
|
||
|
||
#[test]
|
||
fn scales_linearly_keeps_each_sizes_fastest_run() {
|
||
let pairs = |p: Vec<(u64, u64)>| {
|
||
let mut p = p.into_iter().map(|(s, b)| (std::time::Duration::from_millis(s), std::time::Duration::from_millis(b)));
|
||
move || p.next().unwrap_or((std::time::Duration::from_secs(1), std::time::Duration::from_secs(1)))
|
||
};
|
||
let slack = std::time::Duration::from_millis(0);
|
||
// Linear: four times the work, four times the time.
|
||
assert!(scales_linearly(pairs(vec![(5, 20)]), slack).is_ok());
|
||
// A big run slowed by load, then a quiet pair.
|
||
assert!(scales_linearly(pairs(vec![(5, 80), (5, 20)]), slack).is_ok());
|
||
// A quadratic cost (16x) whose later small runs a spike slowed: the fast first one still counts.
|
||
let r = scales_linearly(pairs(vec![(5, 80), (15, 80), (15, 80)]), slack);
|
||
assert!(r.as_ref().is_err_and(|e| e.contains("fastest 0.005 s and 0.080 s, limit 0.040 s")), "{r:?}");
|
||
}
|
||
|
||
/// Issue 602: rounding the edges of a hex boss on a threaded shaft froze the app. The thread's
|
||
/// thousands of facets were healed pair by pair, once per feature after it, and the fillet's
|
||
/// preview then compared each of them with the whole old body.
|
||
///
|
||
/// A ratio and not a limit: a test must not depend on wall-clock timing (CONTRIBUTING.md), the
|
||
/// machine is busy. The longer thread leaves about five times the facets, and the fillet healed
|
||
/// them in a time that grew with their square: linear is about 5x, the quadratic 25x or more.
|
||
#[test]
|
||
fn fillet_beside_a_modelled_thread_finishes() {
|
||
/// The room the noise of a run on a busy machine gets, on top of the ratio.
|
||
const SLACK: std::time::Duration = std::time::Duration::from_millis(500);
|
||
let mut faces = 0;
|
||
if let Err(missed) = scales_linearly(
|
||
|| {
|
||
let (_, small) = fillet_beside_a_thread(1.0);
|
||
let (facets, big) = fillet_beside_a_thread(8.0);
|
||
faces = facets;
|
||
(small, big)
|
||
},
|
||
SLACK,
|
||
) {
|
||
panic!("the fillet beside the thread does not scale linearly: {missed}");
|
||
}
|
||
assert!(faces > 1000, "the thread is faceted: {faces} faces");
|
||
}
|