diff --git a/crates/engine/src/boolean_regression_tests.rs b/crates/engine/src/boolean_regression_tests.rs index 69cb1f5c3..8731e71cb 100644 --- a/crates/engine/src/boolean_regression_tests.rs +++ b/crates/engine/src/boolean_regression_tests.rs @@ -682,7 +682,7 @@ fn ring_notch() -> f64 { } /// The wedge of #1617: a side profile in (y, z) extruded 138 mm along x, its back face leaning -/// by `lean` (the tangent of its angle), with the issue's rounds. The last one runs along the +/// by `lean` (the tangent of its angle), with the issue's rounds, each on the edges it picked. The last one runs along the /// outline of both ends. The issue asked for R1 with `fit: reduce`, which reduces it to 0.854 mm; /// that radius is asked for here directly, which builds the same body without the fit's search /// (about a minute). @@ -700,7 +700,14 @@ fn raked_wedge(lean: f64) -> Session { ("solid.fillet", json!({"body": "Wedge", "radius": 1.2, "edges": [[0, -60, 22]]})), ("solid.fillet", json!({"body": "Wedge", "radius": 1.5, "edges": [[0, -22, 22]]})), ("solid.fillet", json!({"body": "Wedge", "radius": 1.5, "edges": [[0, 38, 60]]})), - ("solid.fillet", json!({"body": "Wedge", "radius": 4, "edges": [[-69, -60, 12], [69, -60, 12], [-69, back, 30], [69, back, 30]]})), + // The issue's R4 rounds these four end edges alone: carried on round the end outline + // (tangent propagation, the feature's default since 84bd2daad, after this test), it would + // run onto the R1.2 round's end arc, where its rail on the end face would be an arc of + // radius 1.2 - 4 < 0. + ( + "solid.fillet", + json!({"body": "Wedge", "radius": 4, "tangent_chain": false, "edges": [[-69, -60, 12], [69, -60, 12], [-69, back, 30], [69, back, 30]]}), + ), ("solid.fillet", json!({"body": "Wedge", "radius": 0.854, "edges": ends})), ]; for (command, params) in steps { diff --git a/crates/engine/src/cmd/sheet_tests.rs b/crates/engine/src/cmd/sheet_tests.rs index bb6e3a362..1f6553bec 100644 --- a/crates/engine/src/cmd/sheet_tests.rs +++ b/crates/engine/src/cmd/sheet_tests.rs @@ -2334,19 +2334,23 @@ fn tiny_cut_inside_exact_circle_survives_unfold_refold_and_dxf() { run(&mut s, "sheet.flange", json!({"sketch": "Disc"})); let circle = s.model.state().sheets[0].base.outer.clone(); let displayed = circle.polyline(1e-3); - let at = (displayed[0] + displayed[1]).normalized().unwrap() * 9.9998; + // A square 0.2 µm across, centred 0.4 µm inside the circle on the bisector of the + // display polyline's first chord (its middle 0.98 µm inside): outside the polyline, inside + // the exact circle, each of its walls and its gap to the rim wider than SMLib's 0.1 µm + // modelling tolerance. + let (half, at) = (0.0001, (displayed[0] + displayed[1]).normalized().unwrap() * 9.9996); assert!(!circle.contains(at)); if initially_flat { run(&mut s, "sheet.unfold", json!({})); } run(&mut s, "sketch.create", json!({"plane": "XY", "name": "TinyCut"})); - run(&mut s, "sketch.rectangle.two_point", json!({"p0": [at.x-0.000025,at.y-0.000025], "p1": [at.x+0.000025,at.y+0.000025]})); + run(&mut s, "sketch.rectangle.two_point", json!({"p0": [at.x-half,at.y-half], "p1": [at.x+half,at.y+half]})); run(&mut s, "sketch.finish", json!({})); run(&mut s, "solid.extrude", json!({"sketch": "TinyCut", "through_all": true, "operation": "cut", "direction": "symmetric"})); for stage in ["sheet.unfold", "sheet.refold"] { let regions = s.model.state().sheets[0].flat_regions().unwrap(); assert_eq!(regions[0].holes.len(), 1); - assert!((regions[0].holes[0].signed_area().abs() - 2.5e-9).abs() < 1e-13); + assert!((regions[0].holes[0].signed_area().abs() - 4e-8).abs() < 1e-13); assert_eq!(s.model.state().bodies.len(), 1); let dxf = run(&mut s, "sheet.export_dxf", json!({}))["dxf"].as_str().unwrap().to_string(); assert_eq!(solidcraft_io::read_dxf(&dxf).unwrap().len(), 5); diff --git a/crates/kernel/src/surface_ruled.rs b/crates/kernel/src/surface_ruled.rs index e6b59fe44..5604e814f 100644 --- a/crates/kernel/src/surface_ruled.rs +++ b/crates/kernel/src/surface_ruled.rs @@ -274,18 +274,27 @@ fn planned(body: &Body, at: &[Vec3], r: &Ruled, handles: &[Option>]) - } } let field = Field { mode, flip: r.flip, distance: d }; - let mut rulings = Vec::with_capacity(n); + // Each edge's face beside it (its surface, whether it is used along its natural normal, + // whether it lies left of the edge: the strip's tangent direction points away from it). + let mut sides = Vec::with_capacity(n); for (j, k) in chosen.iter().enumerate() { let (face, along) = k.and_then(|k| around.get(j)?.get(k).copied()).ok_or_else(|| KernelError::Invalid("a picked edge has no face beside it".into()))?; let surface = surfaces.get(face).and_then(Option::as_ref).ok_or_else(|| KernelError::Failed("ruled surface: a face's surface".into()))?; - // The face lies left of its own boundary seen along its (oriented) normal; the strip's - // tangent direction points away from it. let forward = body.face_forward(face); - let base = bases.get(j).ok_or_else(|| KernelError::Failed("ruled surface: an edge".into()))?; - rulings.push(Rulings { base, face: surface, forward, face_left: along == forward, field: &field }); + sides.push((surface, forward, along == forward)); } - let sampled: Vec = rulings.iter().map(|r| Sampled::of(r, eps)).collect::>()?; + fn rulings_on<'a>(bases: &'a [CurveN<4>], sides: &[(&'a SurfaceEval, bool, bool)], field: &'a Field) -> Vec> { + bases.iter().zip(sides).map(|(base, &(face, forward, face_left))| Rulings { base, face, forward, face_left, field }).collect() + } + let sampled: Vec = rulings_on(&bases, &sides, &field).iter().map(|r| Sampled::of(r, eps)).collect::>()?; + // A free strip's far curve lies in its edge's spline space: a straight edge's (one linear + // span) holds only the chord between the strip's corners, so its rulings' ends would not count. + // Such an edge is taken as the cubic it is too (exact degree elevation, the same points at the + // same parameters), the lowest degree whose interior control points set each end's tangent + // and let the curve pass near the rulings' ends. + let bases: Vec> = bases.into_iter().zip(&sampled).map(|(c, s)| if s.affine.is_none() { cubic_if_straight(c) } else { c }).collect(); + let rulings = rulings_on(&bases, &sides, &field); // Exact strips' far edges are their edges' images; the rest are solved together. let exact: Vec>> = sampled.iter().zip(&bases).map(|(s, base)| s.affine.as_ref().map(|m| mapped(base, |p| m.apply(p)))).collect(); let corner = |r: &Reading| r.0 + r.3 * d; @@ -381,6 +390,18 @@ fn base_curve(r: &Brep, e: usize, forward: bool) -> Result> { Ok(if forward { c } else { reversed(&c) }) } +/// A straight edge's NURBS (degree 1, one span: its two ends) as the cubic Bézier it also is, +/// by exact degree elevation (control points at thirds of the way, weights kept equal); any other +/// curve as it is. +fn cubic_if_straight(c: CurveN<4>) -> CurveN<4> { + let ([p0, p1], [t0, t1]) = match (c.degree, c.ctrl.as_slice(), c.knots.as_slice()) { + (1, [p0, p1], [a, _, _, z]) => ([*p0, *p1], [*a, *z]), + _ => return c, + }; + let mix = |s: f64| std::array::from_fn::(|i| p0[i] * (1.0 - s) + p1[i] * s); + CurveN { degree: 3, knots: vec![t0, t0, t0, t0, t1, t1, t1, t1], ctrl: vec![p0, mix(1.0 / 3.0), mix(2.0 / 3.0), p1] } +} + fn degree(knots: &[f64], n: usize) -> Result { knots.len().checked_sub(n + 1).filter(|d| *d >= 1).ok_or_else(|| KernelError::Invalid("a spline's knots".into())) } @@ -519,7 +540,7 @@ impl Sampled { // Rulings that turn along a free-form edge end on an offset curve, which has no exact NURBS form. // Such a strip's far edge is a curve this module defines instead, and the strip is exactly the // ruled surface between the edge and it: a B-spline on the edge's own degree, knots and weights -// (only its control points are free), from the strip's start corner to its end corner (where the +// (a straight edge's taken as its cubic, `cubic_if_straight`; only its control points are free), from the strip's start corner to its end corner (where the // rulings at the edge's ends reach). Its interior control points are given (the doc's handles) // or, by default, the least-squares solution of these weighted terms, the construction's // parameters: diff --git a/crates/smlib/src/import/analytic.rs b/crates/smlib/src/import/analytic.rs index ce7a61af2..205d61e49 100644 --- a/crates/smlib/src/import/analytic.rs +++ b/crates/smlib/src/import/analytic.rs @@ -105,7 +105,10 @@ fn extruded_circle(u_knots: &[f64], v_knots: &[f64], net: &[Vec<[f64; 4]>], trim return None; } let arc = CurveEval::new(&b::Curve::RationalSpline { knots: arc_knots.to_vec(), homogeneous: first.clone() }).ok()?; - let (center, radius, normal) = circle(&arc, arc_range)?; + // The circle from the arc's widest span, not from the face's range: three points on a + // face a small part of a turn round (6 mm of a 3000 mm radius) put the centre off the + // circle's plane and the radius off by 1e-8 mm, which SMLib does not take back as a cylinder. + let (center, radius, normal) = circle(&arc, widest_span(arc_knots, first.len())?, arc_range)?; let z = d.normalized()?; if normal.cross(z).len() > 1e-9 { return None; @@ -397,7 +400,7 @@ impl Revolution { return Ok((cone, [angle, v])); } // A circular profile. - let (center, radius, normal) = circle(&self.profile, t).ok_or(NOT_ANALYTIC)?; + let (center, radius, normal) = circle(&self.profile, t, t).ok_or(NOT_ANALYTIC)?; let slack = 1e-9 * radius.max(1.0); if normal.dot(self.z).abs() > 1e-9 || normal.dot(x).abs() > 1e-9 || (center - self.o).dot(y).abs() > slack { return Err(NOT_ANALYTIC); @@ -506,11 +509,20 @@ fn agree((record, domain): (&b::Surface, [[f64; 2]; 2]), (analytic, range): (&b: Ok(d < 0.0) } -/// The circle a curve runs along over `t`: centre, radius and unit normal (its turning sense), -/// checked at 65 points within 10⁻⁹ of the radius (at least 1 mm). -fn circle(c: &CurveEval, t: [f64; 2]) -> Option<(Vec3, f64, Vec3)> { +/// The widest knot span of a B-spline with `points` control points on `knots`. +fn widest_span(knots: &[f64], points: usize) -> Option<[f64; 2]> { + let degree = knots.len().checked_sub(points + 1)?; + knots.get(degree..=points)?.windows(2).map(|w| [w[0], w[1]]).max_by(|a, b| (a[1] - a[0]).total_cmp(&(b[1] - b[0]))) +} + +/// The circle a curve runs along over `t`, through its points at `fit` (a range of it on that +/// circle a good part of a turn round, where three points fix the circle to rounding): centre, +/// radius and unit normal (its turning sense over `fit`), checked at 65 points over `t` within +/// 10⁻⁹ of the radius (at least 1 mm). +fn circle(c: &CurveEval, fit: [f64; 2], t: [f64; 2]) -> Option<(Vec3, f64, Vec3)> { + let on = |s: f64| c.point(fit[0] + (fit[1] - fit[0]) * s); let at = |s: f64| c.point(t[0] + (t[1] - t[0]) * s); - let (p, q, r) = (at(0.0)?, at(1.0 / 3.0)?, at(2.0 / 3.0)?); + let (p, q, r) = (on(0.0)?, on(1.0 / 3.0)?, on(2.0 / 3.0)?); let (u, w) = (q - p, r - p); let normal = u.cross(w); let nn = normal.dot(normal); diff --git a/crates/smlib/src/import/tests.rs b/crates/smlib/src/import/tests.rs index 553a18d1e..cf96de0d2 100644 --- a/crates/smlib/src/import/tests.rs +++ b/crates/smlib/src/import/tests.rs @@ -267,3 +267,54 @@ fn only_a_tube_clear_of_its_axis_is_a_ring_torus() { assert!(matches!(ring(major), Surface::PlacedRevolution { .. }), "major {major}"); } } + +/// A 6 mm wide patch of an extruded circle of radius 3000 whose trims straddle the knot where +/// the profile's seam lies (u = 4 of a half circle in two quarter spans): the cylinder takes the +/// patch's own range, 0.002 rad round and 7 high, on the circle exactly. Fitted on the patch's +/// range (three points 2 mm apart) the centre came off the circle's plane by 2.5e-10 mm and the +/// radius off by 8e-9 mm, a cylinder SMLib did not take back from its own NURBS of it. +#[test] +fn a_patch_across_an_extruded_circles_seam_is_its_exact_cylinder() { + let (r, h, half) = (3000.0, 7.0, 0.001); + let c = [10.0 - r, 0.0, 0.0]; + let w = std::f64::consts::FRAC_1_SQRT_2; + let profile = [([c[0], -r], 1.0), ([c[0] + r, -r], w), ([c[0] + r, 0.0], 1.0), ([c[0] + r, r], w), ([c[0], r], 1.0)]; + let homogeneous = profile.iter().map(|&([x, y], wt)| vec![[x * wt, y * wt, 0.0, wt], [x * wt, y * wt, h * wt, wt]]).collect(); + let surface = Surface::RationalSpline { u_knots: vec![3.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 5.0], v_knots: vec![0.0, 0.0, h, h], homogeneous }; + // The quarter span after the seam reaches `half` at quarter_param(half); the one before it + // ends there, so the trims run symmetrically round the knot. + let (u0, u1) = (4.0 - quarter_param(half), 4.0 + quarter_param(half)); + let corners = [[u0, 0.0], [u1, 0.0], [u1, h], [u0, h]]; + let edges: Vec = (0..4) + .map(|k| OrientedEdge { + edge: k as u32, + forward: true, + pcurve: Curve2::Spline { knots: vec![0.0, 0.0, 1.0, 1.0], points: vec![corners[k], corners[(k + 1) % 4]] }, + }) + .collect(); + let line = Curve::Line { start: [0.0; 3], end: [1.0, 0.0, 0.0] }; + let record = Record { + version: b::VERSION, + tolerance: 1e-6, + regions: Vec::new(), + shells: Vec::new(), + faces: vec![Face { surface, nurbs: None, domain: [[3.0, 5.0], [0.0, h]], loops: vec![Loop::Edges { edges }] }], + edges: (0..4) + .map(|_| Edge { nurbs: None, curve: line.clone(), interval: [0.0, 1.0], vertices: [0, 0], tolerance: 1e-6, uses: Vec::new() }) + .collect(), + vertices: Vec::new(), + }; + let made = analytic::analytic(&record).unwrap(); + let f = &made.faces[0]; + let Surface::Cylinder { frame, radius } = &f.surface else { panic!("{:?}", f.surface) }; + assert!((radius - r).abs() <= 1e-10, "radius {radius}"); + let z = cross(frame.x_axis, frame.y_axis); + assert!(z[0].abs() <= 1e-15 && z[1].abs() <= 1e-15 && frame.x_axis[2].abs() <= 1e-15, "axis {z:?}, x {:?}", frame.x_axis); + assert!(frame.origin[2].abs() <= 1e-12 && (frame.origin[0] - c[0]).abs() <= 1e-9 && frame.origin[1].abs() <= 1e-9, "centre {:?}", frame.origin); + // u from the patch's first edge, 2 * half round; v its height. + let [[a0, a1], [v0, v1]] = f.domain; + assert!(a0 == 0.0 && (a1 - 2.0 * half).abs() <= 1e-12, "{:?}", f.domain); + assert!(v0.abs() <= 1e-12 && (v1 - h).abs() <= 1e-12, "{:?}", f.domain); + let start = (-half).sin_cos(); + assert!((frame.x_axis[0] - start.1).abs() <= 1e-12 && (frame.x_axis[1] - start.0).abs() <= 1e-12, "x {:?}", frame.x_axis); +}