Wave 438/509: SMLib import: an extruded circle's circle comes from its widest span, not the face's range (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - fb5ae6cdd jyviko: SMLib import: an extruded circle's circle comes from its widest span, not the face's range - 17a466e6b jyviko: Ruled surface: a free strip on a straight edge gets a far curve that can bend - f2982b47a jyviko: Sheet tests: the tiny cut inside the exact circle is above SMLib's modelling tolerance - cf40a3e6c jyviko: Boolean regression test: the raked wedge's R4 rounds the four edges the issue picked Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -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 {
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -274,18 +274,27 @@ fn planned(body: &Body, at: &[Vec3], r: &Ruled, handles: &[Option<Vec<Vec3>>]) -
|
||||
}
|
||||
}
|
||||
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<Sampled> = rulings.iter().map(|r| Sampled::of(r, eps)).collect::<Result<_>>()?;
|
||||
fn rulings_on<'a>(bases: &'a [CurveN<4>], sides: &[(&'a SurfaceEval, bool, bool)], field: &'a Field) -> Vec<Rulings<'a>> {
|
||||
bases.iter().zip(sides).map(|(base, &(face, forward, face_left))| Rulings { base, face, forward, face_left, field }).collect()
|
||||
}
|
||||
let sampled: Vec<Sampled> = rulings_on(&bases, &sides, &field).iter().map(|r| Sampled::of(r, eps)).collect::<Result<_>>()?;
|
||||
// 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<CurveN<4>> = 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<Option<CurveN<4>>> = 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<CurveN<4>> {
|
||||
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::<f64, 4, _>(|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<usize> {
|
||||
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:
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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<OrientedEdge> = (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);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user