Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Wave 90/509: kernel: solids an SMLib boolean leaves touching come back as separate solids (and 2 more)

jyviko723b84a04473
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs
index 1c6fe0c2ea..9d095aa9e5 100644
--- a/crates/doc/src/eval.rs
+++ b/crates/doc/src/eval.rs
@@ -524,7 +524,27 @@ fn thread_on_impl(
/// profile, 60° flanks): cut from the shaft (external) or the hole wall (internal), running from
/// `start` to `end` along the axis. `radius` is the face's own radius; `open` says which ends
/// of the threaded length are free ends of the face.
+/// The groove of [`thread_groove_shape`] as the faceted solid the truck kernel cuts.
fn thread_groove(t: &ThreadInfo, radius: f64, open: (bool, bool)) -> Result<solidcraft_geom::Mesh> {
+ let g = thread_groove_shape(t, radius, open)?;
+ Ok(kernel::sweep_helix_mesh(&g.plane, &g.section, g.base, g.axis, g.pitch, g.turns, g.stations)?)
+}
+
+/// A thread's groove as a screw sweep: its trapezoid `section` in `plane` (an axial plane
+/// through `base`), carried `turns` turns about `axis` through `base`, rising `pitch` per turn;
+/// `stations` per turn where it is faceted.
+struct GrooveShape {
+ plane: Plane,
+ section: [Vec2; 4],
+ base: Vec3,
+ axis: Vec3,
+ pitch: f64,
+ turns: f64,
+ stations: usize,
+}
+
+/// The shape of [`thread_groove`].
+fn thread_groove_shape(t: &ThreadInfo, radius: f64, open: (bool, bool)) -> Result<GrooveShape> {
let (p, d) = (t.pitch, t.major_diameter);
let h = p * 3f64.sqrt() / 2.0;
let slope = (std::f64::consts::PI / 6.0).tan();
@@ -610,52 +630,7 @@ fn thread_groove(t: &ThreadInfo, radius: f64, open: (bool, bool)) -> Result<soli
crate::ThreadHandedness::Right => (*k, p),
crate::ThreadHandedness::Left => (-*k, -p),
};
- Ok(kernel::sweep_helix_mesh(&plane, &section, base, sweep_axis, sweep_pitch, (s1 - s0) / p, stations as usize)?)
-}
-
-#[cfg(test)]
-mod thread_handedness_tests {
- use super::*;
-
- #[test]
- fn thread_handedness_groove_reflects_exactly_about_the_physical_axis() {
- for direction in [Vec3::Z, Vec3::X, Vec3::new(1.0, 2.0, 3.0)] {
- for internal in [false, true] {
- let axis = UnitVec3::new(direction).unwrap();
- let radius = if internal { 2.5 } else { 3.0 };
- let mut info = ThreadInfo {
- feature: 1,
- body: "Stock".into(),
- designation: "M6x1".into(),
- major_diameter: 6.0,
- radius,
- pitch: 1.0,
- internal,
- handedness: crate::ThreadHandedness::Right,
- axis_point: Vec3::new(7.0, -5.0, 2.0),
- axis,
- start: 1.3,
- end: 4.3,
- };
- let right = thread_groove(&info, radius, (false, true)).unwrap();
- info.handedness = crate::ThreadHandedness::Left;
- let left = thread_groove(&info, radius, (false, true)).unwrap();
- // Reflection in the radial plane of the initial profile, independent of the
- // helix parameterization: the projected coordinate along the axis stays fixed.
- let seed = if axis.x.abs() < 0.9 { Vec3::X } else { Vec3::Y };
- let normal = (seed - *axis * axis.dot(seed)).normalized().unwrap();
- assert_eq!(right.positions.len(), left.positions.len());
- for (r, l) in right.positions.iter().zip(&left.positions) {
- let expected = *r - normal * (2.0 * (*r - info.axis_point).dot(normal));
- assert!((*l - expected).len() < 1e-10, "physical reflection: {direction:?}/{internal}");
- assert!(((*r - *l).dot(*axis)).abs() < 1e-10, "axial extent must not change");
- }
- let (r, l) = (right.measure(), left.measure());
- assert!(r.volume > 0.0 && l.volume > 0.0, "outward, watertight sweep");
- assert!((r.volume - l.volume).abs() < r.volume * 1e-12, "exact tool volume: {r:?}/{l:?}");
- }
- }
- }
+ Ok(GrooveShape { plane, section, base, axis: sweep_axis, pitch: sweep_pitch, turns: (s1 - s0) / p, stations: stations as usize })
}
/// What a modelled external thread turns off a shaft thicker than its major diameter before it
@@ -7241,13 +7216,26 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
}
None => (input, cyl.radius),
};
- let groove = thread_groove(&t, radius, ((t.start - cyl.start).abs() < tol, (t.end - cyl.end).abs() < tol))?;
- // The B-rep boolean can't take helical walls in reasonable time: the body is cut
- // faceted (curved faces within a two-hundredth of the pitch).
- let nb = kernel::faceted_boolean(&input.body, &groove, BoolOp::Cut, t.pitch * 0.005)?
- .ok_or_else(|| DocError::Invalid("the thread removed everything".into()))?;
- // The groove's faces are its triangles, with no role to name them by.
- let groove = crate::lineage::Lineage::unnamed_faces(groove.triangles.len());
+ let open = ((t.start - cyl.start).abs() < tol, (t.end - cyl.end).abs() < tol);
+ let (nb, groove_faces) = match kernel::backend()? {
+ kernel::Backend::Truck => {
+ let groove = thread_groove(&t, radius, open)?;
+ // The B-rep boolean can't take helical walls in reasonable time: the body is cut
+ // faceted (curved faces within a two-hundredth of the pitch).
+ let nb = kernel::faceted_boolean(&input.body, &groove, BoolOp::Cut, t.pitch * 0.005)?;
+ (nb, groove.triangles.len())
+ }
+ kernel::Backend::Smlib => {
+ // SMLib cuts the exact groove: its screw sweep, a B-rep boolean.
+ let g = thread_groove_shape(&t, radius, open)?;
+ let section = Region2 { outer: solidcraft_geom::Loop2::polygon(&g.section), holes: Vec::new() };
+ let groove = kernel::sweep_helix(&g.plane, &section, g.base, g.axis, g.pitch, g.turns)?;
+ (kernel::boolean(&input.body, &groove, BoolOp::Cut)?, groove.face_count())
+ }
+ };
+ let nb = nb.ok_or_else(|| DocError::Invalid("the thread removed everything".into()))?;
+ // The groove's faces have no role to name them by.
+ let groove = crate::lineage::Lineage::unnamed_faces(groove_faces);
let lineage = input.lineage.and_then(|l| crate::lineage::Lineage::step(&nb, &[&l, &groove]));
let nb = Traced { body: nb, lineage };
if let Some(slot) = st.bodies.get_mut(i) {
diff --git a/crates/kernel/src/boolean_history_tests.rs b/crates/kernel/src/boolean_history_tests.rs
index 4f0d26f8bf..ab4bdd6215 100644
--- a/crates/kernel/src/boolean_history_tests.rs
+++ b/crates/kernel/src/boolean_history_tests.rs
@@ -585,6 +585,35 @@ mod smlib {
assert_eq!(meets(h).len(), 4, "{}", show(h));
}
+ /// Cubes sharing an edge, and cubes sharing a vertex: SMLib's union touches itself there;
+ /// it comes back as two closed shells, the shared edge and vertices split into one copy per
+ /// cube, each copy with its edge's history (verified against the geometry).
+ #[test]
+ fn cubes_touching_along_an_edge_or_at_a_vertex_unite_into_two_solids() {
+ let a = boxed(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
+ for (name, b) in [("edge", boxed(10.0, 10.0, 0.0, 20.0, 20.0, 10.0)), ("vertex", boxed(10.0, 10.0, 10.0, 20.0, 20.0, 20.0))] {
+ let r = through_smlib(&a, &b, BoolOp::Union);
+ assert_eq!(r.solid.boundaries().len(), 2, "{name}");
+ assert_eq!((r.face_count(), r.edge_count()), (12, 24), "{name}");
+ let v = crate::measure(&r).unwrap().volume;
+ assert!((v - 2000.0).abs() < 1e-6 * 2000.0, "{name}: {v}");
+ let h = verified(&r, &[&a, &b], 0.02);
+ assert!(h.faces.iter().all(|f| f.origins.len() == 1), "{name}: {}", show(h));
+ }
+ }
+
+ /// Pieces of a cut meeting along a line (two opposite quarters of a slab cut away) come
+ /// back as separate solids rather than a refusal.
+ #[test]
+ fn a_cut_leaving_pieces_along_a_line_gives_two_solids() {
+ let a = boxed(0.0, 0.0, 0.0, 20.0, 20.0, 10.0);
+ let once = through_smlib(&a, &boxed(10.0, -1.0, -1.0, 21.0, 10.0, 11.0), BoolOp::Cut);
+ let r = through_smlib(&once, &boxed(-1.0, 10.0, -1.0, 10.0, 21.0, 11.0), BoolOp::Cut);
+ assert_eq!(r.solid.boundaries().len(), 2);
+ let v = crate::measure(&r).unwrap().volume;
+ assert!((v - 2000.0).abs() < 1e-6 * 2000.0, "{v}");
+ }
+
#[test]
fn disjoint_intersection_is_empty() {
let a = boxed(0.0, 0.0, 0.0, 1.0, 1.0, 1.0);
diff --git a/crates/kernel/src/smlib_boolean.rs b/crates/kernel/src/smlib_boolean.rs
index 789dfdc45c..8f2af04819 100644
--- a/crates/kernel/src/smlib_boolean.rs
+++ b/crates/kernel/src/smlib_boolean.rs
@@ -35,7 +35,18 @@ mod smlib {
BoolOp::Intersect => BooleanOp::Intersect,
};
let Some(r) = ta.boolean(&tb, kind).map_err(|e| failed("operation", e))? else { return Ok(None) };
- let check = r.check(CheckLevel::All).map_err(|e| failed("check", e))?;
+ // Solids touching each other along an edge or at a vertex come back as one non-manifold
+ // body, which the export splits into separate solids: SMLib's check is of those, imported
+ // as given (its check of the touching arrangement itself refuses the radial order of
+ // faces round an edge they share).
+ let manifold = r.is_manifold_solid().map_err(|e| failed("check", e))?;
+ let check = if manifold {
+ r.check(CheckLevel::All).map_err(|e| failed("check", e))?
+ } else {
+ let record = r.to_native().map_err(|e| failed("export", e))?;
+ let split = solidcraft_smlib::Brep::from_record(&record, true).map_err(|e| failed("the separate solids", e))?;
+ split.check(CheckLevel::All).map_err(|e| failed("check", e))?
+ };
if !check.is_valid() {
// Whether an operand failed it already says whose the fault is.
let operands: Vec<&str> = [("the first operand", &sa), ("the second operand", &sb)]
diff --git a/crates/smlib/SMLIB_REV b/crates/smlib/SMLIB_REV
index a4b5678c70..1e7dca84fe 100644
--- a/crates/smlib/SMLIB_REV
+++ b/crates/smlib/SMLIB_REV
@@ -1 +1 @@
-ffcf56d195d1d0c98c5190dd993d61732f099642
+e87e9b3bdc348b00de5238963f387bfa4ba337d6
diff --git a/crates/smlib/src/export.rs b/crates/smlib/src/export.rs
index 35c81ddafb..41b14cf615 100644
--- a/crates/smlib/src/export.rs
+++ b/crates/smlib/src/export.rs
@@ -34,7 +34,7 @@ use solidcraft_geom::Vec3;
use solidcraft_geom::brep as b;
use crate::flat::{self, *};
-use crate::history::Order;
+use crate::history::{Order, Piece};
use crate::import::Arrays;
use crate::{Brep, Result, error, ffi, init};
@@ -576,6 +576,7 @@ enum Loop {
}
/// One edge before renumbering, along its record's parameter.
+#[derive(Clone)]
struct Edge {
curve: b::Curve,
interval: [f64; 2],
@@ -727,66 +728,59 @@ fn native_ordered(arrays: &Arrays) -> Res<(b::Brep, Report, Order)> {
face_uses.get_mut(f).ok_or_else(|| invalid("face"))?.push((s, same));
}
}
- let mut shell_of: Vec<Option<u32>> = vec![None; n_shells];
- let mut shells: Vec<Vec<(u32, bool)>> = Vec::new();
- for s in 0..n_shells {
- if shell_of.get(s).copied().flatten().is_some() {
- continue;
- }
- let uses = shell_faceuses.get(s).ok_or_else(|| invalid("shell"))?;
- let (f0, _) = faceuse(uses.start).map_err(|_| invalid("empty shell"))?;
- let mate = match face_uses.get(f0).map(Vec::as_slice) {
- Some([(a, _), (b, _)]) => {
- if *a == s {
- *b
- } else {
- *a
- }
- }
- _ => return Err(invalid("a face without its two uses")),
- };
- let side = if mate == s {
- s
- } else {
- let (rs, rm) = (region_of.get(s).copied().unwrap_or(0), region_of.get(mate).copied().unwrap_or(0));
- match (material(rs), material(rm)) {
- (false, true) => s,
- (true, false) => mate,
- _ => return Err(unsupported("a shell between two material regions or two empty ones")),
- }
- };
- let mut oriented = Vec::new();
- for fu in shell_faceuses.get(side).ok_or_else(|| invalid("shell"))?.clone() {
+ // Each record shell is one closed boundary between an empty region and a material one: the
+ // faces with the same runtime shell on the empty side and on the material side, as the empty
+ // side uses them. Solids touching along an edge or at a vertex share their empty side's
+ // runtime shell but not their material side's, so each gets its own record shell (the edges
+ // and vertices they share are split below). A sheet's one shell holds both uses of each
+ // face: the `same` one is kept.
+ let mut groups: Vec<((usize, usize), Vec<(u32, bool)>)> = Vec::new();
+ for (s, uses) in shell_faceuses.iter().enumerate() {
+ for fu in uses.clone() {
let (f, same) = faceuse(fu)?;
- // A sheet lists both uses of each face in its one shell: keep the `same` one.
- if mate == s && !same {
- continue;
- }
- if !face_uses.get(f).is_some_and(|u| u.iter().any(|(o, _)| *o == mate)) {
- return Err(unsupported("a shell whose faces' other sides are in different shells"));
- }
+ let key = match face_uses.get(f).map(Vec::as_slice) {
+ Some([(a, _), (b, _)]) if a == b => {
+ if !same {
+ continue;
+ }
+ (*a, *a)
+ }
+ Some([(a, _), (b, _)]) => {
+ let other = if *a == s { *b } else { *a };
+ let (here, there) = (region_of.get(s).copied().unwrap_or(0), region_of.get(other).copied().unwrap_or(0));
+ match (material(here), material(there)) {
+ (false, true) => (s, other),
+ (true, false) => continue,
+ _ => return Err(unsupported("a face between two material regions or two empty ones")),
+ }
+ }
+ _ => return Err(invalid("a face without its two uses")),
+ };
let agrees = faces.get(f).ok_or_else(|| invalid("face"))?.agrees;
- oriented.push((index(f)?, same == agrees));
- }
- let id = index(shells.len())?;
- shells.push(oriented);
- for k in [s, mate] {
- if let Some(slot) = shell_of.get_mut(k) {
- *slot = Some(id);
- }
+ let at = match groups.iter().position(|(k, _)| *k == key) {
+ Some(at) => at,
+ None => {
+ groups.push((key, Vec::new()));
+ groups.len() - 1
+ }
+ };
+ groups.get_mut(at).ok_or_else(|| invalid("shell"))?.1.push((index(f)?, same == agrees));
}
}
let mut regions = Vec::with_capacity(region_shells.len());
for (r, block) in region_shells.iter().enumerate() {
let mut listed = Vec::new();
for s in block.clone() {
- let id = shell_of.get(s).copied().flatten().ok_or_else(|| invalid("shell"))?;
- if !listed.contains(&id) {
- listed.push(id);
+ for (g, ((empty, solid), _)) in groups.iter().enumerate() {
+ let id = index(g)?;
+ if (*empty == s || *solid == s) && !listed.contains(&id) {
+ listed.push(id);
+ }
}
}
regions.push(b::Region { shells: listed, void: r > 0 && !material(r) });
}
+ let shells: Vec<Vec<(u32, bool)>> = groups.into_iter().map(|(_, faces)| faces).collect();
// Shells renumbered in first appearance walking the regions.
let mut order: Vec<u32> = Vec::new();
for r in &regions {
@@ -818,7 +812,10 @@ struct Parts {
/// the edges and then the vertex loops, with each face's pcurves; validated. With it, the
/// canonical index of each array face and edge.
fn canonical(parts: Parts, n_vertices: usize, flat: View, tolerance: f64) -> Res<(b::Brep, Order)> {
- let Parts { faces, edges, shells, regions } = parts;
+ let Parts { mut faces, mut edges, shells, regions } = parts;
+ let n_edges = edges.len();
+ let (edge_source, vertex_source) = split_shared(&mut faces, &mut edges, &shells, n_vertices)?;
+ let n_vertices = vertex_source.len();
let mut face_new: Vec<Option<u32>> = vec![None; faces.len()];
let (mut face_order, mut direction) = (Vec::new(), Vec::new());
for shell in &shells {
@@ -865,7 +862,7 @@ fn canonical(parts: Parts, n_vertices: usize, flat: View, tolerance: f64) -> Res
return Err(unsupported("wire edges from SMLib"));
}
if edge_uses.iter().any(|u| u.len() > 2) {
- return Err(unsupported("the radial order of an edge with more than two uses"));
+ return Err(unsupported("a solid touching itself along an edge"));
}
let mut vertex_new: Vec<Option<u32>> = vec![None; n_vertices];
let mut vertex_order = Vec::new();
@@ -934,7 +931,13 @@ fn canonical(parts: Parts, n_vertices: usize, flat: View, tolerance: f64) -> Res
face_records.push(b::Face { surface: face.surface.clone(), domain: face.domain, loops });
}
let positions = flat.f(VERTEX_POSITION);
- let vertices = vertex_order.iter().map(|&v| Ok(b::Vertex { point: v3(positions, v as usize, "vertex")?, tolerance })).collect::<Res<Vec<_>>>()?;
+ let vertices = vertex_order
+ .iter()
+ .map(|&v| {
+ let at = vertex_source.get(v as usize).copied().ok_or_else(|| invalid("vertex"))?;
+ Ok(b::Vertex { point: v3(positions, at, "vertex")?, tolerance })
+ })
+ .collect::<Res<Vec<_>>>()?;
let shells = shells
.into_iter()
.map(|s| {
@@ -952,10 +955,111 @@ fn canonical(parts: Parts, n_vertices: usize, flat: View, tolerance: f64) -> Res
let placed = |new: &[Option<u32>]| {
new.iter().map(|i| i.map(|i| i as usize).ok_or_else(|| invalid("an entity outside the canonical walk"))).collect::<Res<Vec<_>>>()
};
- let order = Order { faces: placed(&face_new)?, edges: placed(&edge_new)? };
+ let edge_new = placed(&edge_new)?;
+ // SMLib's edges split where solids touch: every piece, with the faces it bounds.
+ let mut pieces = Vec::new();
+ for (e, &canonical) in edge_new.iter().enumerate() {
+ let edge = edge_source.get(e).copied().ok_or_else(|| invalid("edge"))?;
+ if edge_source.iter().filter(|s| **s == edge).count() > 1 {
+ let record = brep.edges.get(canonical).ok_or_else(|| invalid("edge"))?;
+ let faces: std::collections::BTreeSet<usize> = record.uses.iter().map(|u| u.face as usize).collect();
+ pieces.push(Piece { edge, canonical, faces: faces.into_iter().collect() });
+ }
+ }
+ pieces.sort_by_key(|p| (p.edge, p.canonical));
+ let mut edges_out = Vec::with_capacity(n_edges);
+ for e in 0..n_edges {
+ edges_out
+ .push(pieces.iter().find(|p| p.edge == e).map_or_else(|| edge_new.get(e).copied().ok_or_else(|| invalid("edge")), |p| Ok(p.canonical))?);
+ }
+ let order = Order { faces: placed(&face_new)?, edges: edges_out, pieces };
Ok((brep, order))
}
+/// Edges and vertices that solids touching each other share (faces of more than one shell use
+/// them), split into one copy per shell, so each shell is a closed manifold boundary of its own.
+/// The geometry is unchanged. Returns, for every edge and vertex after the split, the array edge
+/// and vertex it is (a copy's original).
+fn split_shared(faces: &mut [Face], edges: &mut Vec<Edge>, shells: &[Vec<(u32, bool)>], n_vertices: usize) -> Res<(Vec<usize>, Vec<usize>)> {
+ let mut shell_of = vec![None; faces.len()];
+ for (k, shell) in shells.iter().enumerate() {
+ for &(f, _) in shell {
+ *shell_of.get_mut(f as usize).ok_or_else(|| invalid("face"))? = Some(k);
+ }
+ }
+ let mut edge_source: Vec<usize> = (0..edges.len()).collect();
+ // Edges: the first shell to use one keeps it, every other gets a copy.
+ let mut edge_shell: Vec<Option<usize>> = vec![None; edges.len()];
+ let mut copies: HashMap<(u32, usize), u32> = HashMap::new();
+ for (f, face) in faces.iter_mut().enumerate() {
+ let Some(k) = shell_of.get(f).copied().flatten() else { continue };
+ for l in &mut face.loops {
+ let Loop::Edges(uses) = l else { continue };
+ for (e, _) in uses.iter_mut() {
+ let slot = edge_shell.get_mut(*e as usize).ok_or_else(|| invalid("edge"))?;
+ match slot {
+ None => *slot = Some(k),
+ Some(owner) if *owner == k => {}
+ Some(_) => {
+ let copy = match copies.get(&(*e, k)) {
+ Some(c) => *c,
+ None => {
+ let c = index(edges.len())?;
+ edges.push(edges.get(*e as usize).ok_or_else(|| invalid("edge"))?.clone());
+ edge_source.push(*e as usize);
+ edge_shell.push(Some(k));
+ copies.insert((*e, k), c);
+ c
+ }
+ };
+ *e = copy;
+ }
+ }
+ }
+ }
+ }
+ // Vertices: likewise, through the edges (each now in one shell) and the vertex loops.
+ let mut vertex_source: Vec<usize> = (0..n_vertices).collect();
+ let mut vertex_shell: Vec<Option<usize>> = vec![None; n_vertices];
+ let mut vertex_copies: HashMap<(u32, usize), u32> = HashMap::new();
+ let mut place = |v: &mut u32, k: usize| -> Res<()> {
+ let slot = vertex_shell.get_mut(*v as usize).ok_or_else(|| invalid("vertex"))?;
+ match slot {
+ None => *slot = Some(k),
+ Some(owner) if *owner == k => {}
+ Some(_) => {
+ let copy = match vertex_copies.get(&(*v, k)) {
+ Some(c) => *c,
+ None => {
+ let c = index(vertex_source.len())?;
+ vertex_source.push(*v as usize);
+ vertex_shell.push(Some(k));
+ vertex_copies.insert((*v, k), c);
+ c
+ }
+ };
+ *v = copy;
+ }
+ }
+ Ok(())
+ };
+ for (e, edge) in edges.iter_mut().enumerate() {
+ let Some(k) = edge_shell.get(e).copied().flatten() else { continue };
+ for v in &mut edge.vertices {
+ place(v, k)?;
+ }
+ }
+ for (f, face) in faces.iter_mut().enumerate() {
+ let Some(k) = shell_of.get(f).copied().flatten() else { continue };
+ for l in &mut face.loops {
+ if let Loop::Vertex(v) = l {
+ place(v, k)?;
+ }
+ }
+ }
+ Ok((edge_source, vertex_source))
+}
+
/// A face's pcurves, edge loop by edge loop, from the plain-record routine on the face's
/// records, each loop moved by whole periods into the face's domain.
fn pcurves(surface: &b::Surface, domain: [[f64; 2]; 2], loops: &[Loop], edges: &[b::Edge], tolerance: f64) -> Res<Vec<Vec<b::Curve2>>> {
diff --git a/crates/smlib/src/ffi.rs b/crates/smlib/src/ffi.rs
index 368d86ca1b..18d2e92b90 100644
--- a/crates/smlib/src/ffi.rs
+++ b/crates/smlib/src/ffi.rs
@@ -7,7 +7,7 @@
use std::ffi::{c_char, c_void};
/// `SMLIB_ABI_VERSION` this crate was written against.
-pub const ABI_VERSION: i32 = 2;
+pub const ABI_VERSION: i32 = 3;
pub const OK: i32 = 0;
pub const ERR_EXCEPTION: i32 = -1000;
diff --git a/crates/smlib/src/history.rs b/crates/smlib/src/history.rs
index a81690ed03..5ad04c3a9b 100644
--- a/crates/smlib/src/history.rs
+++ b/crates/smlib/src/history.rs
@@ -41,10 +41,26 @@ pub struct Raw {
/// Where one body's faces and edges go in canonical order: `faces[i]` is the canonical index of
/// SMLib's face i, likewise for edges. Empty means SMLib's order is the canonical one.
+///
+/// An SMLib edge solids touch along (non-manifold) becomes one record edge per solid:
+/// `edges[i]` is the first of them, and `pieces` lists every piece of such an edge, the first
+/// too, with the canonical faces it bounds.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Order {
pub faces: Vec<usize>,
pub edges: Vec<usize>,
+ pub pieces: Vec<Piece>,
+}
+
+/// One record edge of an SMLib edge split where solids touch along it.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Piece {
+ /// The SMLib edge.
+ pub edge: usize,
+ /// The record edge.
+ pub canonical: usize,
+ /// The canonical faces it bounds, ascending.
+ pub faces: Vec<usize>,
}
impl Brep {
@@ -122,7 +138,23 @@ impl Raw {
}
Ok(at)
};
- let (fat, eat) = (place(&result.faces, self.faces.len())?, place(&result.edges, self.edges.len())?);
+ let fat = place(&result.faces, self.faces.len())?;
+ // Each raw edge's record edges with the faces each bounds where it is split (`None`: as
+ // SMLib has them); together a permutation of the result's edges.
+ let n_edges = self.edges.len() + result.pieces.len() - result.pieces.iter().map(|p| p.edge).collect::<BTreeSet<_>>().len();
+ let mut targets: Vec<(usize, usize, Option<&[usize]>)> = Vec::with_capacity(n_edges);
+ for i in 0..self.edges.len() {
+ let mut split = result.pieces.iter().filter(|p| p.edge == i).peekable();
+ if split.peek().is_none() {
+ targets.push((i, map(&result.edges, i)?, None));
+ } else {
+ targets.extend(split.map(|p| (i, p.canonical, Some(p.faces.as_slice()))));
+ }
+ }
+ let distinct: BTreeSet<usize> = targets.iter().map(|t| t.1).collect();
+ if targets.len() != n_edges || distinct.len() != n_edges || targets.iter().any(|t| t.1 >= n_edges) {
+ return Err(bad("the result's order is no permutation"));
+ }
let mut faces: Vec<Option<FaceProv>> = vec![None; self.faces.len()];
for (f, at) in self.faces.iter().zip(&fat) {
@@ -131,14 +163,20 @@ impl Raw {
}
let faces: Vec<FaceProv> = faces.into_iter().collect::<Option<_>>().ok_or(bad("the result's order is no permutation"))?;
- let mut edges: Vec<Option<EdgeProv>> = vec![None; self.edges.len()];
- for (e, at) in self.edges.iter().zip(&eat) {
- let bounds: BTreeSet<usize> = e
- .faces
- .iter()
- .map(|f| fat.get(*f).copied().ok_or(bad("an edge lies on a face outside the result")))
- .collect::<std::result::Result<_, _>>()?;
- let bounds: Vec<usize> = bounds.into_iter().collect();
+ let mut edges: Vec<Option<EdgeProv>> = vec![None; n_edges];
+ for &(i, at, split) in &targets {
+ let e = self.edges.get(i).ok_or(bad("an edge lies outside the result"))?;
+ let bounds: Vec<usize> = match split {
+ Some(faces) => faces.to_vec(),
+ None => {
+ let bounds: BTreeSet<usize> = e
+ .faces
+ .iter()
+ .map(|f| fat.get(*f).copied().ok_or(bad("an edge lies on a face outside the result")))
+ .collect::<std::result::Result<_, _>>()?;
+ bounds.into_iter().collect()
+ }
+ };
let origins = if e.origins.is_empty() {
// New: where its two faces meet, each side what that face came from.
let side = |f: usize| faces.get(f).and_then(|p| Side::new(p.origins.iter().copied()));
@@ -157,7 +195,7 @@ impl Raw {
.collect::<std::result::Result<_, Failed>>()?;
set.into_iter().collect()
};
- edges[*at] = Some(EdgeProv { faces: bounds, origins });
+ *edges.get_mut(at).ok_or(bad("the result's order is no permutation"))? = Some(EdgeProv { faces: bounds, origins });
}
let edges: Vec<EdgeProv> = edges.into_iter().collect::<Option<_>>().ok_or(bad("the result's order is no permutation"))?;
Ok(History { operands: operands.len(), faces, edges })
diff --git a/crates/smlib/src/history/tests.rs b/crates/smlib/src/history/tests.rs
index bf457034d2..06ecf734bf 100644
--- a/crates/smlib/src/history/tests.rs
+++ b/crates/smlib/src/history/tests.rs
@@ -60,9 +60,9 @@ fn renumbers_into_canonical_order() {
let raw = Raw::decode(RECORDS).unwrap();
// Operand 0's SMLib face 2 is its canonical face 5, edge 7 its edge 0; the result's faces
// and edges are listed backwards.
- let a = Order { faces: vec![1, 2, 5, 0, 3, 4], edges: vec![1, 2, 3, 4, 5, 6, 7, 0] };
- let b = Order { faces: vec![0, 1, 2, 3, 4], edges: vec![0, 1, 2, 3] };
- let result = Order { faces: vec![2, 1, 0], edges: vec![2, 1, 0] };
+ let a = Order { faces: vec![1, 2, 5, 0, 3, 4], edges: vec![1, 2, 3, 4, 5, 6, 7, 0], pieces: vec![] };
+ let b = Order { faces: vec![0, 1, 2, 3, 4], edges: vec![0, 1, 2, 3], pieces: vec![] };
+ let result = Order { faces: vec![2, 1, 0], edges: vec![2, 1, 0], pieces: vec![] };
let h = raw.history(&[a, b], &result).unwrap();
assert_eq!(h.faces[2].origins, vec![face(0, 5)]);
assert_eq!(h.faces[0].origins, vec![face(0, 1), face(1, 0)]);
@@ -79,10 +79,10 @@ fn bad_orders_are_errors() {
// An origin on an operand that isn't there.
assert!(raw.history(std::slice::from_ref(&ok), &ok).is_err());
// An operand order too short for an origin.
- assert!(raw.history(&[Order { faces: vec![0], edges: vec![] }, ok.clone()], &ok).is_err());
+ assert!(raw.history(&[Order { faces: vec![0], edges: vec![], pieces: vec![] }, ok.clone()], &ok).is_err());
// A result order that isn't a permutation.
- assert!(raw.history(&[ok.clone(), ok.clone()], &Order { faces: vec![0, 0, 1], edges: vec![] }).is_err());
- assert!(raw.history(&[ok.clone(), ok.clone()], &Order { faces: vec![0, 1, 3], edges: vec![] }).is_err());
+ assert!(raw.history(&[ok.clone(), ok.clone()], &Order { faces: vec![0, 0, 1], edges: vec![], pieces: vec![] }).is_err());
+ assert!(raw.history(&[ok.clone(), ok.clone()], &Order { faces: vec![0, 1, 3], edges: vec![], pieces: vec![] }).is_err());
}
/// A box with its edge 0 (between faces 4 and 5) filleted, as SMLib reports it: the fillet face
diff --git a/tests/kernel-cases/threads/1443-m5x0.7-thread-in-5mm-hole/expected.json b/tests/kernel-cases/threads/1443-m5x0.7-thread-in-5mm-hole/expected.json
index 593fc5d223..3fde5d60ad 100644
--- a/tests/kernel-cases/threads/1443-m5x0.7-thread-in-5mm-hole/expected.json
+++ b/tests/kernel-cases/threads/1443-m5x0.7-thread-in-5mm-hole/expected.json
@@ -1,32 +1,13 @@
{
"sources": [
"tangency-labs/solidcraft#1443",
- "tangency-labs/solidcraft#3060"
+ "tangency-labs/solidcraft#3060",
+ "tangency-labs/solidcraft#1018",
+ "tangency-labs/solidcraft#2853"
],
- "what": "a modelled M5x0.7 thread in a 5 mm hole drawn at the thread's nominal size (was refused: it would cut 0.00 mm of the thread's depth)",
+ "what": "a modelled thread on a hole that isn't the thread's size: refused with the size to use, never a silent change of the hole",
"source": "analytic",
- "method": "ISO 68-1 basic profile: H = P sqrt3/2, basic depth 5H/8. External groove (the space between teeth): a trapezoid P/4 wide at the root radius d/2 - 5H/8, widening by 2 tan30 per unit of radius to 7P/8 at d/2. Internal groove: P/8 wide at the major radius d/2, widening to 3P/4 at the minor radius, cut only where there is material (r >= hole radius). Pappus: volume per turn = 2 pi A rc (A the trapezoid area, rc its centroid radius from the axis); a helical sweep of L/P turns removes exactly (L/P) x that, where each end of the thread is a free end or lies inside material. A 5 mm hole through a D14 x 4.2 disc, drawn at the thread's nominal size, takes a modelled M5x0.7: the hole is first filled to the tap drill (major - pitch = 4.3 mm, rho=2.15), then the groove is cut, the same thread as in a hole drilled at the tap drill. Whole length, both ends free (6 turns): V = pi 7^2 4.2 - pi 2.15^2 4.2 - 6 x V_turn(clipped at rho) = 646.5398 - 60.9925 - 6 x 1.45465 = 576.8194 mm3. The thin lips a tap leaves at each end are below 0.2% of the volume. Tolerance 1%: a modelled thread is a faceted helical solid (radial chord error up to 1% of the pitch on every wall, i.e. a volume deficit of about 4/3 x sag/R).",
- "outcome": "solid",
- "body_count": 1,
- "volume_mm3": 576.8194,
- "tolerance": {
- "rel": 0.01
- },
- "bbox": {
- "min": [
- -7,
- -7,
- 0
- ],
- "max": [
- 7,
- 7,
- 4.2
- ]
- },
- "center_of_mass": [
- 0,
- 0,
- 2.1
- ]
+ "method": "Decision (#1018, #2853): a modelled thread never changes the size of the hole it is on; one that isn't the thread's size is refused, naming the size to use. A fill-to-tap-drill or turn-down option would be opt-in, off by default (see #3060), and get its own case. The refusal's numbers, from ISO 68-1 (H = P sqrt3/2, basic depth 5H/8): M5x0.7: tap drill = 5 - 0.7 = 4.3 mm; depth 5H/8 = 5/8 x 0.7 x sqrt3/2 = 0.379 mm; the 5 mm hole is at the major diameter, so nothing would be cut. Expected message: \"this 5 mm hole is too wide for a modelled M5x0.7 thread: it would cut 0.00 mm of the thread's 0.38 mm depth; drill 4.3 mm for M5x0.7, or thread this hole M6\".",
+ "outcome": "refused",
+ "refusal": "this 5 mm hole is too wide for a modelled M5x0.7 thread: it would cut 0.00 mm of the thread's 0.38 mm depth; drill 4.3 mm for M5x0.7, or thread this hole M6"
}
diff --git a/tests/kernel-cases/threads/2152-m3x0.2-thread-in-3mm-hole/expected.json b/tests/kernel-cases/threads/2152-m3x0.2-thread-in-3mm-hole/expected.json
index a3ea11f12c..c10e0becdb 100644
--- a/tests/kernel-cases/threads/2152-m3x0.2-thread-in-3mm-hole/expected.json
+++ b/tests/kernel-cases/threads/2152-m3x0.2-thread-in-3mm-hole/expected.json
@@ -1,31 +1,12 @@
{
"sources": [
- "tangency-labs/solidcraft#2152"
+ "tangency-labs/solidcraft#2152",
+ "tangency-labs/solidcraft#1018",
+ "tangency-labs/solidcraft#2853"
],
- "what": "a modelled M3x0.2 thread in a 3 mm hole drawn at the thread's nominal size (was refused like any hole at the nominal size)",
+ "what": "a modelled thread on a hole that isn't the thread's size: refused with the size to use, never a silent change of the hole",
"source": "analytic",
- "method": "ISO 68-1 basic profile: H = P sqrt3/2, basic depth 5H/8. External groove (the space between teeth): a trapezoid P/4 wide at the root radius d/2 - 5H/8, widening by 2 tan30 per unit of radius to 7P/8 at d/2. Internal groove: P/8 wide at the major radius d/2, widening to 3P/4 at the minor radius, cut only where there is material (r >= hole radius). Pappus: volume per turn = 2 pi A rc (A the trapezoid area, rc its centroid radius from the axis); a helical sweep of L/P turns removes exactly (L/P) x that, where each end of the thread is a free end or lies inside material. A 3 mm hole through a D10 x 2 disc, drawn at the thread's nominal size, takes a modelled M3x0.2: the hole is first filled to the tap drill (major - pitch = 2.8 mm, rho=1.4), then the groove is cut, the same thread as in a hole drilled at the tap drill. Whole length, both ends free (10 turns): V = pi 5^2 2 - pi 1.4^2 2 - 10 x V_turn(clipped at rho) = 157.0796 - 12.3150 - 10 x 0.07477 = 144.0169 mm3. The thin lips a tap leaves at each end are below 0.2% of the volume. Tolerance 1%: a modelled thread is a faceted helical solid (radial chord error up to 1% of the pitch on every wall, i.e. a volume deficit of about 4/3 x sag/R).",
- "outcome": "solid",
- "body_count": 1,
- "volume_mm3": 144.0169,
- "tolerance": {
- "rel": 0.01
- },
- "bbox": {
- "min": [
- -5,
- -5,
- 0
- ],
- "max": [
- 5,
- 5,
- 2
- ]
- },
- "center_of_mass": [
- 0,
- 0,
- 1.0
- ]
+ "method": "Decision (#1018, #2853): a modelled thread never changes the size of the hole it is on; one that isn't the thread's size is refused, naming the size to use. A fill-to-tap-drill or turn-down option would be opt-in, off by default (see #3060), and get its own case. The refusal's numbers, from ISO 68-1 (H = P sqrt3/2, basic depth 5H/8): M3x0.2: tap drill = 3 - 0.2 = 2.8 mm; depth 5H/8 = 5/8 x 0.2 x sqrt3/2 = 0.108 mm; the 3 mm hole is at the major diameter. Expected message: \"this 3 mm hole is too wide for a modelled M3x0.2 thread: it would cut 0.00 mm of the thread's 0.11 mm depth; drill 2.8 mm for M3x0.2, or thread this hole M4\".",
+ "outcome": "refused",
+ "refusal": "this 3 mm hole is too wide for a modelled M3x0.2 thread: it would cut 0.00 mm of the thread's 0.11 mm depth; drill 2.8 mm for M3x0.2, or thread this hole M4"
}
diff --git a/tests/kernel-cases/threads/2369-m8-thread-in-6.3mm-hole-bored-to-minor/expected.json b/tests/kernel-cases/threads/2369-m8-thread-in-6.3mm-hole-bored-to-minor/expected.json
deleted file mode 100644
index c5d33d5628..0000000000
--- a/tests/kernel-cases/threads/2369-m8-thread-in-6.3mm-hole-bored-to-minor/expected.json
+++ /dev/null
@@ -1,33 +0,0 @@
-{
- "sources": [
- "tangency-labs/solidcraft#2369",
- "tangency-labs/solidcraft#2688",
- "tangency-labs/solidcraft#2853"
- ],
- "what": "a modelled M8 thread in a hole narrower than the thread's minor diameter (6.3 mm, and 6 mm in #2688), refused as 'the face is too far from the thread's diameter'",
- "source": "analytic",
- "method": "ISO 68-1 basic profile: H = P sqrt3/2, basic depth 5H/8. External groove (the space between teeth): a trapezoid P/4 wide at the root radius d/2 - 5H/8, widening by 2 tan30 per unit of radius to 7P/8 at d/2. Internal groove: P/8 wide at the major radius d/2, widening to 3P/4 at the minor radius, cut only where there is material (r >= hole radius). Pappus: volume per turn = 2 pi A rc (A the trapezoid area, rc its centroid radius from the axis); a helical sweep of L/P turns removes exactly (L/P) x that, where each end of the thread is a free end or lies inside material. A 6.3 mm hole through a D16 x 5 disc takes a modelled M8 (P=1.25). The hole is narrower than the thread's minor diameter 8 - 2 x 5H/8 = 6.6468 mm (ISO D1 = D - 1.0825 P), so a tap takes the extra material off first: the hole is bored out to the minor diameter (rho=3.3234) and the groove cut from there. Whole length (4 turns): V = pi 8^2 5 - pi rho^2 5 - 4 x V_turn(clipped at rho) = 1005.3096 - 173.4961 - 4 x 8.32555 = 798.5114 mm3. Tolerance 1%: a modelled thread is a faceted helical solid (radial chord error up to 1% of the pitch on every wall, i.e. a volume deficit of about 4/3 x sag/R).",
- "outcome": "solid",
- "body_count": 1,
- "volume_mm3": 798.5114,
- "center_of_mass": [
- 0,
- 0,
- 2.5
- ],
- "tolerance": {
- "rel": 0.01
- },
- "bbox": {
- "min": [
- -8,
- -8,
- 0
- ],
- "max": [
- 8,
- 8,
- 5
- ]
- }
-}
diff --git a/tests/kernel-cases/threads/2369-m8-thread-in-6.3mm-hole-refused/expected.json b/tests/kernel-cases/threads/2369-m8-thread-in-6.3mm-hole-refused/expected.json
new file mode 100644
index 0000000000..913f3ee0d4
--- /dev/null
+++ b/tests/kernel-cases/threads/2369-m8-thread-in-6.3mm-hole-refused/expected.json
@@ -0,0 +1,13 @@
+{
+ "sources": [
+ "tangency-labs/solidcraft#2369",
+ "tangency-labs/solidcraft#2688",
+ "tangency-labs/solidcraft#2853",
+ "tangency-labs/solidcraft#1018"
+ ],
+ "what": "a modelled thread on a hole that isn't the thread's size: refused with the size to use, never a silent change of the hole",
+ "source": "analytic",
+ "method": "Decision (#1018, #2853): a modelled thread never changes the size of the hole it is on; one that isn't the thread's size is refused, naming the size to use. A fill-to-tap-drill or turn-down option would be opt-in, off by default (see #3060), and get its own case. The refusal's numbers, from ISO 68-1 (H = P sqrt3/2, basic depth 5H/8): M8 (P 1.25): tap drill = 8 - 1.25 = 6.75 mm; basic minor diameter D1 = 8 - 2 x 5H/8 = 8 - 1.353 = 6.647 mm; a 6.3 mm hole is below the minor diameter, so the thread's teeth would fill part of the hole. Expected message: \"this 6.3 mm hole is too narrow for a modelled M8 thread (its teeth would fill the hole); drill 6.75 mm for M8\".",
+ "outcome": "refused",
+ "refusal": "this 6.3 mm hole is too narrow for a modelled M8 thread (its teeth would fill the hole); drill 6.75 mm for M8"
+}
diff --git a/tests/kernel-cases/threads/2369-m8-thread-in-6.3mm-hole-bored-to-minor/recipe.json b/tests/kernel-cases/threads/2369-m8-thread-in-6.3mm-hole-refused/recipe.json
similarity index 100%
rename from tests/kernel-cases/threads/2369-m8-thread-in-6.3mm-hole-bored-to-minor/recipe.json
rename to tests/kernel-cases/threads/2369-m8-thread-in-6.3mm-hole-refused/recipe.json
diff --git a/tests/kernel-cases/threads/2705-m14-thread-on-14.6mm-boss-turned-to-major/expected.json b/tests/kernel-cases/threads/2705-m14-thread-on-14.6mm-boss-turned-to-major/expected.json
deleted file mode 100644
index 2303baf8e7..0000000000
--- a/tests/kernel-cases/threads/2705-m14-thread-on-14.6mm-boss-turned-to-major/expected.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
- "sources": [
- "tangency-labs/solidcraft#2705"
- ],
- "what": "a modelled M14 thread on a 14.6 mm boss, slightly thicker than the thread (refused: the face is too far from the thread's diameter)",
- "source": "analytic",
- "method": "ISO 68-1 basic profile: H = P sqrt3/2, basic depth 5H/8. External groove (the space between teeth): a trapezoid P/4 wide at the root radius d/2 - 5H/8, widening by 2 tan30 per unit of radius to 7P/8 at d/2. Internal groove: P/8 wide at the major radius d/2, widening to 3P/4 at the minor radius, cut only where there is material (r >= hole radius). Pappus: volume per turn = 2 pi A rc (A the trapezoid area, rc its centroid radius from the axis); a helical sweep of L/P turns removes exactly (L/P) x that, where each end of the thread is a free end or lies inside material. A 14.6 mm boss (R=7.3, 15 tall) on a 20x20x4 plate takes a modelled M14 (P=2) over 10 mm from its free top end. The boss is thicker than the major diameter, so a die turns it down to 14 mm over the threaded length first (ring pi (7.3^2 - 7^2) 10 = 134.7743) and the groove is cut from there (5 turns, 50.18900 each). V = 1600 + pi 7.3^2 15 - 134.7743 - 5 x 50.18900 = 3725.5127 mm3. The groove's last end may nick the unturned boss by well under 0.2 mm3. Tolerance 1%: a modelled thread is a faceted helical solid (radial chord error up to 1% of the pitch on every wall, i.e. a volume deficit of about 4/3 x sag/R).",
- "outcome": "solid",
- "body_count": 1,
- "volume_mm3": 3725.5127,
- "tolerance": {
- "rel": 0.01
- },
- "bbox": {
- "min": [
- -10,
- -10,
- 0
- ],
- "max": [
- 10,
- 10,
- 19
- ]
- }
-}
diff --git a/tests/kernel-cases/threads/2705-m14-thread-on-14.6mm-shaft-refused/expected.json b/tests/kernel-cases/threads/2705-m14-thread-on-14.6mm-shaft-refused/expected.json
new file mode 100644
index 0000000000..b645141044
--- /dev/null
+++ b/tests/kernel-cases/threads/2705-m14-thread-on-14.6mm-shaft-refused/expected.json
@@ -0,0 +1,12 @@
+{
+ "sources": [
+ "tangency-labs/solidcraft#2705",
+ "tangency-labs/solidcraft#1018",
+ "tangency-labs/solidcraft#2853"
+ ],
+ "what": "a modelled thread on a shaft that isn't the thread's size: refused with the size to use, never a silent change of the shaft",
+ "source": "analytic",
+ "method": "Decision (#1018, #2853): a modelled thread never changes the size of the shaft it is on; one that isn't the thread's size is refused, naming the size to use. A fill-to-tap-drill or turn-down option would be opt-in, off by default (see #3060), and get its own case. The refusal's numbers, from ISO 68-1 (H = P sqrt3/2, basic depth 5H/8): M14: an external thread's major diameter is 14 mm; a 14.6 mm shaft is above it, so the thread would have to turn the shaft down. Expected message: \"this 14.6 mm shaft is too thick for a modelled M14 thread; make the shaft 14 mm for M14\".",
+ "outcome": "refused",
+ "refusal": "this 14.6 mm shaft is too thick for a modelled M14 thread; make the shaft 14 mm for M14"
+}
diff --git a/tests/kernel-cases/threads/2705-m14-thread-on-14.6mm-boss-turned-to-major/recipe.json b/tests/kernel-cases/threads/2705-m14-thread-on-14.6mm-shaft-refused/recipe.json
similarity index 100%
rename from tests/kernel-cases/threads/2705-m14-thread-on-14.6mm-boss-turned-to-major/recipe.json
rename to tests/kernel-cases/threads/2705-m14-thread-on-14.6mm-shaft-refused/recipe.json
diff --git a/tests/kernel-cases/threads/2969-m48x0.75-thread-in-48mm-hole/expected.json b/tests/kernel-cases/threads/2969-m48x0.75-thread-in-48mm-hole/expected.json
index f7b48aa59d..cd0168e5d8 100644
--- a/tests/kernel-cases/threads/2969-m48x0.75-thread-in-48mm-hole/expected.json
+++ b/tests/kernel-cases/threads/2969-m48x0.75-thread-in-48mm-hole/expected.json
@@ -1,31 +1,12 @@
{
"sources": [
- "tangency-labs/solidcraft#2969"
+ "tangency-labs/solidcraft#2969",
+ "tangency-labs/solidcraft#1018",
+ "tangency-labs/solidcraft#2853"
],
- "what": "a modelled M48x0.75 internal thread in a 48 mm hole drawn at the thread's nominal size",
+ "what": "a modelled thread on a hole that isn't the thread's size: refused with the size to use, never a silent change of the hole",
"source": "analytic",
- "method": "ISO 68-1 basic profile: H = P sqrt3/2, basic depth 5H/8. External groove (the space between teeth): a trapezoid P/4 wide at the root radius d/2 - 5H/8, widening by 2 tan30 per unit of radius to 7P/8 at d/2. Internal groove: P/8 wide at the major radius d/2, widening to 3P/4 at the minor radius, cut only where there is material (r >= hole radius). Pappus: volume per turn = 2 pi A rc (A the trapezoid area, rc its centroid radius from the axis); a helical sweep of L/P turns removes exactly (L/P) x that, where each end of the thread is a free end or lies inside material. A 48 mm hole through a D54 x 3 disc, drawn at the thread's nominal size, takes a modelled M48x0.75: the hole is first filled to the tap drill (major - pitch = 47.25 mm, rho=23.625), then the groove is cut, the same thread as in a hole drilled at the tap drill. Whole length, both ends free (4 turns): V = pi 27^2 3 - pi 23.625^2 3 - 4 x V_turn(clipped at rho) = 6870.6631 - 5260.3515 - 4 x 17.37563 = 1540.8091 mm3. The thin lips a tap leaves at each end are below 0.2% of the volume. Tolerance 1%: a modelled thread is a faceted helical solid (radial chord error up to 1% of the pitch on every wall, i.e. a volume deficit of about 4/3 x sag/R).",
- "outcome": "solid",
- "body_count": 1,
- "volume_mm3": 1540.8091,
- "tolerance": {
- "rel": 0.01
- },
- "bbox": {
- "min": [
- -27,
- -27,
- 0
- ],
- "max": [
- 27,
- 27,
- 3
- ]
- },
- "center_of_mass": [
- 0,
- 0,
- 1.5
- ]
+ "method": "Decision (#1018, #2853): a modelled thread never changes the size of the hole it is on; one that isn't the thread's size is refused, naming the size to use. A fill-to-tap-drill or turn-down option would be opt-in, off by default (see #3060), and get its own case. The refusal's numbers, from ISO 68-1 (H = P sqrt3/2, basic depth 5H/8): M48x0.75: tap drill = 48 - 0.75 = 47.25 mm; depth 5H/8 = 5/8 x 0.75 x sqrt3/2 = 0.406 mm; the 48 mm hole is at the major diameter. Expected message: \"this 48 mm hole is too wide for a modelled M48x0.75 thread: it would cut 0.00 mm of the thread's 0.41 mm depth; drill 47.25 mm for M48x0.75, or thread this hole M56\".",
+ "outcome": "refused",
+ "refusal": "this 48 mm hole is too wide for a modelled M48x0.75 thread: it would cut 0.00 mm of the thread's 0.41 mm depth; drill 47.25 mm for M48x0.75, or thread this hole M56"
}
diff --git a/tests/kernel-cases/threads/3366-m20-thread-in-20mm-hole/expected.json b/tests/kernel-cases/threads/3366-m20-thread-in-20mm-hole/expected.json
index 94019f9725..ccc00ad3ff 100644
--- a/tests/kernel-cases/threads/3366-m20-thread-in-20mm-hole/expected.json
+++ b/tests/kernel-cases/threads/3366-m20-thread-in-20mm-hole/expected.json
@@ -1,32 +1,13 @@
{
"sources": [
"tangency-labs/solidcraft#3366",
- "tangency-labs/solidcraft#3367"
+ "tangency-labs/solidcraft#3367",
+ "tangency-labs/solidcraft#1018",
+ "tangency-labs/solidcraft#2853"
],
- "what": "a modelled M20 internal thread in a 20 mm hole, made after the 20 mm cylinder's own thread",
+ "what": "a modelled thread on a hole that isn't the thread's size: refused with the size to use, never a silent change of the hole",
"source": "analytic",
- "method": "ISO 68-1 basic profile: H = P sqrt3/2, basic depth 5H/8. External groove (the space between teeth): a trapezoid P/4 wide at the root radius d/2 - 5H/8, widening by 2 tan30 per unit of radius to 7P/8 at d/2. Internal groove: P/8 wide at the major radius d/2, widening to 3P/4 at the minor radius, cut only where there is material (r >= hole radius). Pappus: volume per turn = 2 pi A rc (A the trapezoid area, rc its centroid radius from the axis); a helical sweep of L/P turns removes exactly (L/P) x that, where each end of the thread is a free end or lies inside material. A 20 mm hole through a D48 x 10 disc, drawn at the thread's nominal size, takes a modelled M20: the hole is first filled to the tap drill (major - pitch = 17.5 mm, rho=8.75), then the groove is cut, the same thread as in a hole drilled at the tap drill. Whole length, both ends free (4 turns): V = pi 24^2 10 - pi 8.75^2 10 - 4 x V_turn(clipped at rho) = 18095.5737 - 2405.2819 - 4 x 74.96751 = 15390.4218 mm3. The thin lips a tap leaves at each end are below 0.2% of the volume. Tolerance 1%: a modelled thread is a faceted helical solid (radial chord error up to 1% of the pitch on every wall, i.e. a volume deficit of about 4/3 x sag/R).",
- "outcome": "solid",
- "body_count": 1,
- "volume_mm3": 15390.4218,
- "tolerance": {
- "rel": 0.01
- },
- "bbox": {
- "min": [
- -24,
- -24,
- 0
- ],
- "max": [
- 24,
- 24,
- 10
- ]
- },
- "center_of_mass": [
- 0,
- 0,
- 5.0
- ]
+ "method": "Decision (#1018, #2853): a modelled thread never changes the size of the hole it is on; one that isn't the thread's size is refused, naming the size to use. A fill-to-tap-drill or turn-down option would be opt-in, off by default (see #3060), and get its own case. The refusal's numbers, from ISO 68-1 (H = P sqrt3/2, basic depth 5H/8): M20 (P 2.5): tap drill = 20 - 2.5 = 17.5 mm; depth 5H/8 = 5/8 x 2.5 x sqrt3/2 = 1.353 mm; the 20 mm hole is at the major diameter. Expected message: \"this 20 mm hole is too wide for a modelled M20 thread: it would cut 0.00 mm of the thread's 1.35 mm depth; drill 17.5 mm for M20, or thread this hole M22\".",
+ "outcome": "refused",
+ "refusal": "this 20 mm hole is too wide for a modelled M20 thread: it would cut 0.00 mm of the thread's 1.35 mm depth; drill 17.5 mm for M20, or thread this hole M22"
}
diff --git a/tests/kernel-cases/threads/995-m5-thread-in-5mm-hole/expected.json b/tests/kernel-cases/threads/995-m5-thread-in-5mm-hole/expected.json
index 5069a84e04..ae0f679579 100644
--- a/tests/kernel-cases/threads/995-m5-thread-in-5mm-hole/expected.json
+++ b/tests/kernel-cases/threads/995-m5-thread-in-5mm-hole/expected.json
@@ -1,32 +1,12 @@
{
"sources": [
"tangency-labs/solidcraft#995",
- "tangency-labs/solidcraft#1018"
+ "tangency-labs/solidcraft#1018",
+ "tangency-labs/solidcraft#2853"
],
- "what": "a modelled M5 thread in a hole drawn at 5 mm, the thread's own size (nothing was cut: the wall only turned faceted)",
+ "what": "a modelled thread on a hole that isn't the thread's size: refused with the size to use, never a silent change of the hole",
"source": "analytic",
- "method": "ISO 68-1 basic profile: H = P sqrt3/2, basic depth 5H/8. External groove (the space between teeth): a trapezoid P/4 wide at the root radius d/2 - 5H/8, widening by 2 tan30 per unit of radius to 7P/8 at d/2. Internal groove: P/8 wide at the major radius d/2, widening to 3P/4 at the minor radius, cut only where there is material (r >= hole radius). Pappus: volume per turn = 2 pi A rc (A the trapezoid area, rc its centroid radius from the axis); a helical sweep of L/P turns removes exactly (L/P) x that, where each end of the thread is a free end or lies inside material. A 5 mm hole through a D14 x 4 disc, drawn at the thread's nominal size, takes a modelled M5: the hole is first filled to the tap drill (major - pitch = 4.2 mm, rho=2.1), then the groove is cut, the same thread as in a hole drilled at the tap drill. Whole length, both ends free (5 turns): V = pi 7^2 4 - pi 2.1^2 4 - 5 x V_turn(clipped at rho) = 615.7522 - 55.4177 - 5 x 1.87431 = 550.9629 mm3. The thin lips a tap leaves at each end are below 0.2% of the volume. Tolerance 1%: a modelled thread is a faceted helical solid (radial chord error up to 1% of the pitch on every wall, i.e. a volume deficit of about 4/3 x sag/R).",
- "outcome": "solid",
- "body_count": 1,
- "volume_mm3": 550.9629,
- "tolerance": {
- "rel": 0.01
- },
- "bbox": {
- "min": [
- -7,
- -7,
- 0
- ],
- "max": [
- 7,
- 7,
- 4
- ]
- },
- "center_of_mass": [
- 0,
- 0,
- 2.0
- ]
+ "method": "Decision (#1018, #2853): a modelled thread never changes the size of the hole it is on; one that isn't the thread's size is refused, naming the size to use. A fill-to-tap-drill or turn-down option would be opt-in, off by default (see #3060), and get its own case. The refusal's numbers, from ISO 68-1 (H = P sqrt3/2, basic depth 5H/8): M5 (P 0.8): tap drill = 5 - 0.8 = 4.2 mm; basic depth 5H/8 = 5/8 x 0.8 x sqrt3/2 = 0.433 mm; a 5 mm hole is at the major diameter, so the internal thread (major d, minor d - 2 x 5H/8) cuts 0.00 mm. Expected message: \"this 5 mm hole is too wide for a modelled M5 thread: it would cut 0.00 mm of the thread's 0.43 mm depth; drill 4.2 mm for M5, or thread this hole M6\".",
+ "outcome": "refused",
+ "refusal": "this 5 mm hole is too wide for a modelled M5 thread: it would cut 0.00 mm of the thread's 0.43 mm depth; drill 4.2 mm for M5, or thread this hole M6"
}