SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Cut a hole tangent inside a stepped boss (zero-thickness curved wall) (#986)
froglemonade23669d4b3d0db
diff --git a/crates/kernel/src/pinch_tests.rs b/crates/kernel/src/pinch_tests.rsindex 322c6569a9..7fd7331e95 100644--- a/crates/kernel/src/pinch_tests.rs+++ b/crates/kernel/src/pinch_tests.rs@@ -112,3 +112,96 @@ fn hole_touching_the_outline_stays_one_piece() {let res = boolean(&small, &big, BoolOp::Union).unwrap().unwrap();assert_solid(&res, std::f64::consts::PI * (100.0 + 144.0) * 10.0, 1e-5, 1, "disc tangent inside a larger one");}++/// A Ø40 base with a Ø20 boss on it touching its rim from inside at (20, 0), and a Ø10 hole at+/// (15, 0) touching both rims there: the material on either side of the hole meets along the+/// line x = 20, y = 0 only (a zero-thickness curved wall). The hole cut through both, the boss+/// only and the base only, all exact (no tool nudge); then the same turned 30° and mirrored.+#[test]+fn hole_tangent_inside_a_stepped_boss_cuts_exactly() {+ use std::f64::consts::PI;+ for (turn, flip) in [(0.0, 1.0), (PI / 6.0, 1.0), (0.0, -1.0)] {+ let at = |x: f64, y: f64| Vec2::new(x * turn.cos() - flip * y * turn.sin(), x * turn.sin() + flip * y * turn.cos());+ let circle = |x: f64, r: f64| Loop2::circle(at(x, 0.), r);+ let base = prism(circle(0., 20.), 0., 5.);+ let boss = prism(circle(10., 10.), 5., 15.);+ let stepped = boolean(&base, &boss, BoolOp::Union).unwrap().unwrap();+ for (z0, z1, want) in [(-1., 20., 2000. + 1000. - 25. * 15.), (6., 20., 2000. + 1000. - 25. * 9.), (-1., 4., 2000. + 1000. - 25. * 4.)] {+ let what = format!("hole z {z0}…{z1}, turned {turn}, flip {flip}");+ let hole = prism(circle(15., 5.), z0, z1);+ let (res, d) = capture_boolean_diagnostics(|| boolean(&stepped, &hole, BoolOp::Cut));+ let res = res.unwrap_or_else(|e| panic!("{what}: {e}")).unwrap();+ assert_solid(&res, PI * want, 1e-5, 1, &what);+ assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{what}: {d:?}");+ }+ }+}++/// A square hole in a stepped block whose side lies on the block's side: planar walls meeting+/// along a line at no angle are not a zero-thickness wall but one flat side, and a hole tangent+/// to the side of a square boss on a block cuts exactly.+#[test]+fn hole_tangent_to_a_flat_side_of_a_stepped_block_cuts_exactly() {+ let block = prism(rect(0., 0., 40., 40.), 0., 5.);+ let boss = prism(rect(10., 10., 40., 30.), 5., 15.);+ let stepped = boolean(&block, &boss, BoolOp::Union).unwrap().unwrap();+ let hole = prism(disc(35., 20., 5.), -1., 20.);+ let (res, d) = capture_boolean_diagnostics(|| boolean(&stepped, &hole, BoolOp::Cut));+ let res = res.unwrap().unwrap();+ assert_solid(&res, 8000. + 6000. - std::f64::consts::PI * 25. * 15., 1e-5, 1, "hole tangent to a flat side");+ assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{d:?}");+}++/// A stepped block cut by a disc tangent to its back side from inside leaves two posts meeting+/// only along the tangent line: the stepped prism route keeps them apart (its edge sheets bound+/// the posts, as in the single-height case above) rather than sewing one shell pinched along the+/// line. A diamond hole with a corner on the side of a stepped block is one piece: the material+/// goes round the hole.+#[test]+fn stepped_cuts_touching_along_a_line_keep_their_pieces() {+ let block = prism(rect(0., 0., 31., 29.), 0., 10.);+ let back = prism(rect(0., 20., 25., 29.), 10., 20.);+ let stepped = boolean(&block, &back, BoolOp::Union).unwrap().unwrap();+ let tool = prism(disc(18.5, 4., 25.), -1., 21.);+ let (res, d) = capture_boolean_diagnostics(|| boolean(&stepped, &tool, BoolOp::Cut));+ let res = res.unwrap().unwrap();+ let n = 400_000;+ let dx = 31.0 / n as f64;+ let post = |x: f64| (29.0 - (4.0 + (625.0 - (x - 18.5).powi(2)).max(0.0).sqrt()).min(29.0)).max(0.0);+ let volume: f64 = (0..n)+ .map(|i| {+ let x = (i as f64 + 0.5) * dx;+ post(x) * dx * if x < 25.0 { 20.0 } else { 10.0 }+ })+ .sum();+ let v = res.tessellate(1e-4).unwrap().measure().volume;+ assert!((v - volume).abs() <= volume * 1e-4, "posts: volume {v} vs {volume}");+ assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{d:?}");+ let sewn = crate::prism::prism_boolean(&stepped, &tool, BoolOp::Cut);+ assert!(!matches!(&sewn, Some(Ok(Some(b))) if b.shell_count() < 2), "posts sewn into one shell");++ let block = prism(rect(0., 0., 40., 40.), 0., 5.);+ let boss = prism(rect(10., 10., 40., 30.), 5., 15.);+ let stepped = boolean(&block, &boss, BoolOp::Union).unwrap().unwrap();+ let diamond = prism(poly(&[[30., 20.], [35., 15.], [40., 20.], [35., 25.]]), -1., 20.);+ let (res, d) = capture_boolean_diagnostics(|| boolean(&stepped, &diamond, BoolOp::Cut));+ let res = res.unwrap().unwrap();+ assert_solid(&res, 8000. + 6000. - 50. * 15., 1e-9, 1, "diamond hole with a corner on a stepped side");+ assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "{d:?}");+}++/// A row of holes each touching the next (a 5 mm pattern of Ø5 holes) through a stepped plate:+/// the walls between them have no thickness, and the cut is exact.+#[test]+fn row_of_touching_holes_through_a_stepped_plate_cuts_exactly() {+ let plate = prism(rect(0., 0., 30., 35.), 0., 7.5);+ let notch = prism(rect(0., 30., 22.5, 50.), 2.5, 25.);+ let mut body = boolean(&plate, ¬ch, BoolOp::Cut).unwrap().unwrap();+ for x in [15.45, 20.45, 25.45] {+ let hole = prism(disc(x, 15.7, 2.5), -5., 7.5);+ let (res, d) = capture_boolean_diagnostics(|| boolean(&body, &hole, BoolOp::Cut));+ body = res.unwrap().unwrap();+ assert!(!d.events.iter().any(|e| e.strategy == BooleanStrategy::ToolNudge), "hole at {x}: {d:?}");+ }+ assert_solid(&body, 7312.5 - 3.0 * std::f64::consts::PI * 6.25 * 7.5, 1e-5, 1, "touching holes");+}diff --git a/crates/kernel/src/sew.rs b/crates/kernel/src/sew.rsindex e7769a2596..d3c247f3e5 100644--- a/crates/kernel/src/sew.rs+++ b/crates/kernel/src/sew.rs@@ -185,66 +185,208 @@ pub(crate) fn sew_touching_with_sources(faces: &[FaceSpec], sources: &[Option<crtype EdgeUse = (usize, usize, usize);-fn touching_sheets(faces: &[FaceSpec]) -> Result<HashMap<EdgeUse, usize>> {- type Use = (EdgeUse, Vec3, Vec3, Vec3);- let mut uses: HashMap<(Key, Key), Vec<Use>> = HashMap::new();+/// Below this angle (radians) two faces leave an edge the same way: tangent faces, ordered by+/// their curvature.+const SAME_WAY: f64 = 1e-6;++/// Where more than two faces meet along a straight edge (bodies touching along a line, or a wall+/// of no thickness), which faces bound each sheet of it (each sheet gets its own edge), and the+/// vertex fans that follow from that (see [`corner_fans`]). Only edges on planes and on the walls+/// of extruded arcs are looked at.+///+/// Each sheet bounds a wedge of material, so that pieces of material meeting along an edge stay+/// apart, except where that would make a face touch itself: a hole touching the outline from+/// inside (tangent, or at a corner) leaves its caps an outline and a hole meeting at the edge's+/// end, which with the material kept apart would share a vertex, and a face can't have that.+/// The material there goes round the hole, and the edges ending at such points get sheets that+/// bound the empty wedges instead: the hole's wall on either side is one sheet, the outline's+/// the other.+fn touching_sheets(faces: &[FaceSpec]) -> Result<(HashMap<EdgeUse, usize>, HashMap<Corner, usize>)> {+ let mut uses: HashMap<(Key, Key), Vec<(EdgeUse, Vec3, Vec3)>> = HashMap::new();for (fi, face) in faces.iter().enumerate() {- let Some(outer) = face.loops.first() else { continue };- let normal = outer- .iter()- .fold(Vec3::ZERO, |n, e| {- let (a, b) = e.ends();- n + a.cross(b)- })- .normalized();+ if !matches!(face.surface, SurfSpec::Plane | SurfSpec::Extruded { .. }) {+ continue;+ }for (li, lp) in face.loops.iter().enumerate() {for (ei, e) in lp.iter().enumerate() {- if matches!(e, EdgeSpec::Line { .. }) && matches!(face.surface, SurfSpec::Plane) {- let (a, b) = e.ends();- let (ka, kb) = (key(a), key(b));+ if let EdgeSpec::Line { a, b } = e {+ let (ka, kb) = (key(*a), key(*b));let k = if ka < kb { (ka, kb) } else { (kb, ka) };- if let Some(n) = normal {- uses.entry(k).or_default().push(((fi, li, ei), a, b, n));- }+ uses.entry(k).or_default().push(((fi, li, ei), *a, *b));}}}}- let mut sheets = HashMap::new();- for group in uses.values().filter(|g| g.len() > 2) {- if group.len() != 4 {- return Err(KernelError::Invalid("sew: unsupported edge contact".into()));+ // Each contact edge: its ends, both ways of pairing its faces, and whether the second is used.+ let mut contacts = Vec::new();+ for (ends, group) in uses.iter().filter(|(_, g)| g.len() > 2) {+ let [material, empty] = edge_sheets(faces, group)?;+ contacts.push((*ends, material, empty, false));+ }+ if contacts.is_empty() {+ return Ok((HashMap::new(), corner_fans(faces, &HashMap::new())));+ }+ let sheets_of = |contacts: &[((Key, Key), [[EdgeUse; 2]; 2], [[EdgeUse; 2]; 2], bool)]| -> HashMap<EdgeUse, usize> {+ let mut sheets = HashMap::new();+ for (_, material, empty, round) in contacts {+ for (sheet, pair) in (if *round { empty } else { material }).iter().enumerate() {+ for u in pair {+ sheets.insert(*u, sheet);+ }+ }}- let mut paired = std::collections::HashSet::new();- for (i, (use_a, a, b, n)) in group.iter().enumerate() {- if paired.contains(&i) {- continue;+ sheets+ };+ // Each pass turns at least one edge round, and none back.+ loop {+ let sheets = sheets_of(&contacts);+ let fans = corner_fans(faces, &sheets);+ let touching = self_touching(faces, &fans);+ let mut turned = false;+ for (ends, _, _, round) in &mut contacts {+ if !*round && (touching.contains(&ends.0) || touching.contains(&ends.1)) {+ *round = true;+ turned = true;+ }+ }+ if !turned {+ return Ok((sheets, fans));+ }+ }+}++/// The points where a face has two corners at one vertex (its loops would touch there).+fn self_touching(faces: &[FaceSpec], fans: &HashMap<Corner, usize>) -> std::collections::HashSet<Key> {+ let mut seen = std::collections::HashSet::new();+ let mut out = std::collections::HashSet::new();+ for (fi, f) in faces.iter().enumerate() {+ for (li, l) in f.loops.iter().enumerate() {+ for (ei, e) in l.iter().enumerate() {+ let at = key(e.ends().0);+ if !seen.insert((at, fans.get(&(fi, li, ei)).copied().unwrap_or(0), fi)) {+ out.insert(at);+ }}- let t = (*b - *a).normalized().ok_or_else(|| KernelError::Invalid("sew: a degenerate contact".into()))?;- // Pair the two faces bounding each material wedge, not the empty- // wedge between them. Each pair uses the edge in opposite directions.- let j = group- .iter()- .enumerate()- .find_map(|(j, (_, c, d, m))| {- (i != j- && !paired.contains(&j)- && key(*a) == key(*d)- && key(*b) == key(*c)- && n.cross(t).dot(*m) < -1e-8- && m.cross(-t).dot(*n) < -1e-8)- .then_some(j)- })- .ok_or_else(|| KernelError::Invalid("sew: ambiguous edge contact".into()))?;- let use_b = group.get(j).ok_or_else(|| KernelError::Invalid("sew: edge contact".into()))?.0;- let sheet = paired.len() / 2;- sheets.insert(*use_a, sheet);- sheets.insert(use_b, sheet);- paired.insert(i);- paired.insert(j);}}- Ok(sheets)+ out+}++/// The two ways of making sheets of an edge four faces meet along, as the pairs of faces+/// bounding each: around the wedges of material between them, and around the empty ones.+///+/// Seen along the edge, each face leaves it as a curve; going round the edge, material and empty+/// wedges between them alternate. Faces are ordered by the way they leave the edge and, where+/// they leave it the same way (tangent faces), by how fast they turn from it: the order of+/// points a short way into each face, as in 2D loop chaining (`prism::tightest_left`).+fn edge_sheets(faces: &[FaceSpec], group: &[(EdgeUse, Vec3, Vec3)]) -> Result<[[[EdgeUse; 2]; 2]; 2]> {+ let fail = |s: &str| KernelError::Invalid(format!("sew: {s}"));+ let (Some((_, a0, b0)), 4) = (group.first(), group.len()) else { return Err(fail("unsupported edge contact")) };+ let t = (if key(*a0) < key(*b0) { *b0 - *a0 } else { *a0 - *b0 }).normalized().ok_or_else(|| fail("a degenerate contact"))?;+ // Each face: its use, where the use starts, the way into it, its turn, its material side, and+ // the angle of the way into it from the first face's.+ let mut rays = Vec::with_capacity(4);+ let mut reference = None;+ for (u, a, b) in group {+ let face = faces.get(u.0).ok_or_else(|| fail("edge contact"))?;+ let (into, turn, ccw) = leaving(face, *a, *b, t).ok_or_else(|| fail("unsupported edge contact"))?;+ let r: Vec3 = *reference.get_or_insert(into);+ let angle = r.cross(into).dot(t).atan2(r.dot(into)).rem_euclid(std::f64::consts::TAU);+ rays.push((*u, key(*a), turn, ccw, if angle > std::f64::consts::TAU - SAME_WAY { 0.0 } else { angle }));+ }+ rays.sort_by(|p, q| p.4.total_cmp(&q.4));+ // Faces leaving the same way, by their turn (a total order on each, which a comparison with+ // a tolerance is not).+ for i in 1..rays.len() {+ let mut j = i;+ while let (Some(p), Some(q)) = (rays.get(j.wrapping_sub(1)), rays.get(j)) {+ if q.4 - p.4 > SAME_WAY || p.2 <= q.2 {+ break;+ }+ rays.swap(j - 1, j);+ j -= 1;+ }+ }+ let wedges: Vec<_> = rays.iter().zip(rays.iter().cycle().skip(1)).collect();+ // Each wedge's faces must use the edge in opposite directions, and be told apart (faces+ // leaving the same way and turning alike lie on each other).+ let same_way = |p: f64, q: f64| {+ let gap = (q - p).rem_euclid(std::f64::consts::TAU);+ gap <= SAME_WAY || gap >= std::f64::consts::TAU - SAME_WAY+ };+ let alike = |p: f64, q: f64| (p - q).abs() <= 1e-9 * p.abs().max(q.abs()).max(1e-9);+ if wedges.iter().any(|(p, q)| p.3 == q.3 || p.1 == q.1 || (same_way(p.4, q.4) && alike(p.2, q.2))) {+ return Err(fail("ambiguous edge contact"));+ }+ let pairs = |material: bool| -> Result<[[EdgeUse; 2]; 2]> {+ let mut it = wedges.iter().filter(|(p, _)| p.3 == material).map(|(p, q)| [p.0, q.0]);+ match (it.next(), it.next()) {+ (Some(x), Some(y)) => Ok([x, y]),+ _ => Err(fail("ambiguous edge contact")),+ }+ };+ Ok([pairs(true)?, pairs(false)?])+}++/// How a face leaves the straight edge `a`→`b` it bounds, seen along the edge's direction `t`:+/// the way into the face square to the edge, how fast it turns from that way (its curvature,+/// positive counter-clockwise about `t`; 0 for a plane), and whether its material is on its+/// counter-clockwise side. None for other faces, and for an extruded wall the edge is not a+/// ruling of.+fn leaving(face: &FaceSpec, a: Vec3, b: Vec3, t: Vec3) -> Option<(Vec3, f64, bool)> {+ let along = (b - a).normalized()?;+ // The outward normal along the edge, and the centre of curvature (with its curvature).+ let (outward, centre) = match &face.surface {+ SurfSpec::Plane => (plane_normal(face)?, None),+ SurfSpec::Extruded { a: sa, b: sb, mid, dir } => {+ let k = dir.normalized()?;+ if along.dot(k).abs() < 1.0 - 1e-9 {+ return None;+ }+ let centre = circumcentre(*sa, *mid, *sb)?;+ let radial = |p: Vec3| {+ let r = p - centre;+ r - k * r.dot(k)+ };+ let r = radial(a);+ let (p, out) = face.probe?;+ let side = if radial(p).dot(out) < 0.0 { -1.0 } else { 1.0 };+ (r.normalized()? * side, Some((centre, 1.0 / r.len())))+ }+ _ => return None,+ };+ // A face's loops run counter-clockwise about its outward normal: it lies on their left.+ let into = outward.cross(along).normalized()?;+ let left = t.cross(into);+ let turn = match centre {+ None => 0.0,+ Some((c, curvature)) if (c - a).dot(left) > 0.0 => curvature,+ Some((_, curvature)) => -curvature,+ };+ turn.is_finite().then_some((into, turn, left.dot(outward) < 0.0))+}++/// The unit normal a planar face's outer loop runs counter-clockwise about (through its arcs'+/// midpoints and chains' control points, so that a loop of one line and one arc has one).+fn plane_normal(face: &FaceSpec) -> Option<Vec3> {+ let n = face.loops.first()?.iter().fold(Vec3::ZERO, |n, e| match e {+ EdgeSpec::Line { a, b } => n + a.cross(*b),+ EdgeSpec::Arc { a, b, mid } => n + a.cross(*mid) + mid.cross(*b),+ EdgeSpec::Chain { ctrl } => ctrl.iter().zip(ctrl.iter().skip(1)).fold(n, |n, (p, q)| n + p.cross(*q)),+ });+ n.normalized()+}++/// The centre of the circle through three points; None when they are in line.+fn circumcentre(a: Vec3, b: Vec3, c: Vec3) -> Option<Vec3> {+ let (u, v) = (b - a, c - a);+ let w = u.cross(v);+ let d = 2.0 * w.dot(w);+ if !(d > 1e-300) {+ return None;+ }+ let p = a + (v.cross(w) * u.dot(u) + w.cross(u) * v.dot(v)) * (1.0 / d);+ p.is_finite().then_some(p)}/// A loop corner: face, loop, and the edge of the loop that starts there.@@ -518,10 +660,9 @@ fn sew_impl(faces: &[FaceSpec], touching: bool, sources: Option<&[Option<crate::}}guard("sew", || {- let sheets = if touching { touching_sheets(faces)? } else { HashMap::new() };// Separate fans at a point only where contact is expected (as for edge sheets); a plain// sew refuses bodies touching at a vertex.- let fans = if touching { corner_fans(faces, &sheets) } else { HashMap::new() };+ let (sheets, fans) = if touching { touching_sheets(faces)? } else { (HashMap::new(), HashMap::new()) };let fan = |c: Corner| fans.get(&c).copied().unwrap_or(0);let mut cache = Cache::default();let mut out: Vec<mt::Face> = Vec::with_capacity(faces.len());diff --git a/tests/robustness/goldens.json b/tests/robustness/goldens.jsonindex 0e810365d5..9777f92ebb 100644--- a/tests/robustness/goldens.json+++ b/tests/robustness/goldens.json@@ -43,7 +43,7 @@"39": {"area":1892.050815,"bodies":1,"edges":27,"error":null,"faces":11,"outcome":"ok","rejected":0,"shells":1,"steps":["extruded profile","chamfer","cut sphere","rectangular pattern"],"unsupported":1,"volume":4040.62787},"40": {"area":15548.516294,"bodies":1,"edges":49,"error":"offset: a corner whose faces don't meet the same way after t","faces":22,"outcome":"failed","rejected":0,"shells":1,"steps":["extruded profile","cut cylinder","shell","cut cylinder","join cylinder","shell"],"unsupported":0,"volume":16543.777532},"41": {"area":7611.393446,"bodies":1,"edges":99,"error":null,"faces":35,"outcome":"ok","rejected":1,"shells":1,"steps":["box","cut sphere","shell","fillet","cut cylinder","rectangular pattern","cut sphere","join cylinder"],"unsupported":1,"volume":5973.93328},- "42": {"area":5486.881252,"bodies":1,"edges":45,"error":null,"faces":17,"outcome":"ok","rejected":0,"shells":1,"steps":["extruded profile","cut box","cut cylinder","rectangular pattern"],"unsupported":0,"volume":19095.110963},+ "42": {"area":5486.877622,"bodies":1,"edges":63,"error":null,"faces":20,"outcome":"ok","rejected":0,"shells":1,"steps":["extruded profile","cut box","cut cylinder","rectangular pattern"],"unsupported":0,"volume":19095.106157},"43": {"area":3492.988343,"bodies":1,"edges":72,"error":null,"faces":26,"outcome":"ok","rejected":2,"shells":1,"steps":["extruded profile","cut cylinder","rectangular pattern","fillet","hole","rectangular pattern","join cylinder"],"unsupported":1,"volume":7528.548742},"44": {"area":7972.435565,"bodies":1,"edges":36,"error":null,"faces":15,"outcome":"ok","rejected":0,"shells":1,"steps":["extruded profile","shell","cut sphere"],"unsupported":0,"volume":7622.184369},"45": {"area":14416.876392,"bodies":2,"edges":62,"error":"boolean Union: implausible result volume ","faces":29,"outcome":"failed","rejected":0,"shells":3,"steps":["revolved section","join cylinder","fillet","shell","cut box","join box"],"unsupported":1,"volume":14286.791174},@@ -52,7 +52,7 @@"48": {"area":9651.031297,"bodies":1,"edges":66,"error":null,"faces":28,"outcome":"ok","rejected":0,"shells":1,"steps":["extruded profile","hole","circular pattern","join box","shell","cut box"],"unsupported":2,"volume":7044.773463},"49": {"area":7512.5,"bodies":1,"edges":24,"error":null,"faces":11,"outcome":"ok","rejected":0,"shells":1,"steps":["box","join box"],"unsupported":0,"volume":40546.875},"50": {"area":9387.513708,"bodies":2,"edges":48,"error":null,"faces":20,"outcome":"ok","rejected":1,"shells":2,"steps":["extruded profile","fillet","join cylinder","join cylinder","fillet","cut box","cut cylinder"],"unsupported":1,"volume":40128.140215},- "51": {"area":3316.022299,"bodies":1,"edges":51,"error":null,"faces":21,"outcome":"ok","rejected":0,"shells":1,"steps":["box","cut box","hole","rectangular pattern","chamfer","chamfer"],"unsupported":1,"volume":6812.582331},+ "51": {"area":4230.232922,"bodies":1,"edges":66,"error":null,"faces":26,"outcome":"ok","rejected":1,"shells":2,"steps":["box","cut box","hole","rectangular pattern","chamfer","join box"],"unsupported":1,"volume":8742.066663},"52": {"area":7851.282527,"bodies":1,"edges":32,"error":null,"faces":14,"outcome":"ok","rejected":0,"shells":1,"steps":["box","shell","cut cylinder","chamfer","fillet"],"unsupported":0,"volume":5741.788461},"53": {"area":17168.464938,"bodies":1,"edges":110,"error":null,"faces":46,"outcome":"ok","rejected":1,"shells":4,"steps":["extruded profile","cut cylinder","shell","join cylinder","circular pattern","fillet"],"unsupported":0,"volume":16607.030819},"54": {"area":7080.555724,"bodies":4,"edges":90,"error":null,"faces":38,"outcome":"ok","rejected":0,"shells":4,"steps":["extruded profile","join box","circular pattern","cut cylinder","cut box","join cylinder","cut cylinder"],"unsupported":3,"volume":15737.224446},@@ -110,6 +110,7 @@{"reason":"#921 with its grid lines kept to display and export meshes (Booleans mesh as before #921): measured volume and area move by about 1e-6 (seed 94 also as in #936)","seeds":[22,78,94]},{"reason":"a hole placed on a face without a direction drills into that face (it took the direction from any face whose plane passed through the point, the last one found, such as a side of a patterned box standing on the point's plane): the holes on these seeds now go straight in (#950)","seeds":[7,21,85]},{"reason":"the last-resort tool nudge is tried the other way when it fails or leaves sliver faces the operands didn't have: seed 43's join builds and the design runs to the end, 31 and 78 come out with fewer faces (#827, #897)","seeds":[31,43,78]},- {"reason":"main's fillet changes since the last record (#926, #949) move seeds 33 and 91: a fillet step builds differently or is picked differently","seeds":[33,91]}+ {"reason":"main's fillet changes since the last record (#926, #949) move seeds 33 and 91: a fillet step builds differently or is picked differently","seeds":[33,91]},+ {"reason":"hole tangent inside a stepped boss: touching sews split zero-thickness curved walls, so a pattern of holes spaced by their diameter (touching) in a stepped body cuts exactly instead of by a tool nudge: 42 builds more faces (the walls split where the holes touch), 51 picks other edges afterwards","seeds":[42,51]}]}