Wave 238/509: geom: a face's box reaches its boundary's extremes, not its samples' (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. -903e371fajyviko: geom: a face's box reaches its boundary's extremes, not its samples' -cfe1b8b92jyviko: step: a loop through its surface's pole has its seam -0bea4631bjyviko: kernel: IGES trim pieces that miss their meeting point are closed onto it -0e6681a2djyviko: kernel: the largest fitting fillet shrinks only on a refusal as too large Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
1 parent
a5fc58bfed
commit
2425f8b453
8 files changed
+210
-32
No files matched your search
@@ -697,7 +697,7 @@ fn fillet_fitted(
|
||||
fit: crate::FilletFit,
|
||||
) -> std::result::Result<(kernel::Body, Option<Vec<f64>>), kernel::KernelError> {
|
||||
match kernel::fillet(body, edges, r) {
|
||||
Err(kernel::KernelError::TooLarge(why)) if fit == crate::FilletFit::Reduce => match kernel::fillet_max_each(body, edges, r) {
|
||||
Err(kernel::KernelError::TooLarge(why)) if fit == crate::FilletFit::Reduce => match kernel::fillet_max_each(body, edges, r)? {
|
||||
// Built at the radius asked for after all (the groups apart): nothing reduced.
|
||||
Some((used, b)) => Ok((b, used.iter().any(|u| *u < r).then_some(used))),
|
||||
None => Err(kernel::KernelError::TooLarge(why)),
|
||||
|
||||
@@ -317,6 +317,32 @@ pub fn edge<'a>(
|
||||
/// Points per edge along a loop taken for a face's extent.
|
||||
const EXTENT_POINTS: usize = 32;
|
||||
|
||||
/// The largest value of `f` on `[a, b]`, where it rises to one peak and falls (golden section, to
|
||||
/// rounding; the ends count).
|
||||
fn golden_max(f: &dyn Fn(f64) -> f64, a: f64, b: f64) -> f64 {
|
||||
const R: f64 = 0.618_033_988_749_894_8;
|
||||
let (mut a, mut b) = (a, b);
|
||||
let best = f(a).max(f(b));
|
||||
let (mut c, mut d) = (b - R * (b - a), a + R * (b - a));
|
||||
let (mut fc, mut fd) = (f(c), f(d));
|
||||
while b - a > 1e-15 * (1.0 + a.abs().max(b.abs())) {
|
||||
if fc >= fd {
|
||||
b = d;
|
||||
d = c;
|
||||
fd = fc;
|
||||
c = b - R * (b - a);
|
||||
fc = f(c);
|
||||
} else {
|
||||
a = c;
|
||||
c = d;
|
||||
fc = fd;
|
||||
d = a + R * (b - a);
|
||||
fd = f(d);
|
||||
}
|
||||
}
|
||||
best.max(fc).max(fd)
|
||||
}
|
||||
|
||||
/// The parameter box of a face on `label` over its boundary: each loop's points (`loops`, in
|
||||
/// order along each loop) projected onto the label, a periodic parameter unwrapped from one point
|
||||
/// to the next, and each loop after the first a whole number of periods along where that keeps
|
||||
@@ -334,17 +360,23 @@ pub fn extent(label: &Surface, loops: &[Vec<(&Curve, [f64; 2], bool)>]) -> Optio
|
||||
let mut prev: Option<[f64; 2]> = None;
|
||||
for (c, [t0, t1], forward) in l {
|
||||
let curve = super::eval::CurveEval::new(c).ok()?;
|
||||
for k in 0..=EXTENT_POINTS {
|
||||
let f = k as f64 / EXTENT_POINTS as f64;
|
||||
let t = if *forward { t0 * (1.0 - f) + t1 * f } else { t1 * (1.0 - f) + t0 * f };
|
||||
let mut q = eval.project(curve.point(t)?, prev, f64::INFINITY)?;
|
||||
if let Some(p) = prev {
|
||||
// The point at `t` on the label, a periodic parameter unwrapped next to `near`.
|
||||
let at = |t: f64, near: Option<[f64; 2]>| -> Option<[f64; 2]> {
|
||||
let mut q = eval.project(curve.point(t)?, near, f64::INFINITY)?;
|
||||
if let Some(p) = near {
|
||||
for d in 0..2 {
|
||||
if let Some(Some(per)) = period.get(d) {
|
||||
q[d] += ((p[d] - q[d]) / per).round() * per;
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(q)
|
||||
};
|
||||
let mut samples: Vec<(f64, [f64; 2], [bool; 2])> = Vec::with_capacity(EXTENT_POINTS + 1);
|
||||
for k in 0..=EXTENT_POINTS {
|
||||
let f = k as f64 / EXTENT_POINTS as f64;
|
||||
let t = if *forward { t0 * (1.0 - f) + t1 * f } else { t1 * (1.0 - f) + t0 * f };
|
||||
let q = at(t, prev)?;
|
||||
// At a pole the collapsed parameter is anything: it bounds nothing.
|
||||
let pole = eval.pole(q);
|
||||
for d in 0..2 {
|
||||
@@ -356,6 +388,36 @@ pub fn extent(label: &Surface, loops: &[Vec<(&Curve, [f64; 2], bool)>]) -> Optio
|
||||
if !pole.iter().any(|p| *p) {
|
||||
prev = Some(q);
|
||||
}
|
||||
samples.push((t, q, pole));
|
||||
}
|
||||
// A sample is a point of the boundary, not its extreme: each sample higher (or lower)
|
||||
// than its neighbours brackets an extreme of the edge, which is found there.
|
||||
for k in 0..samples.len() {
|
||||
let (_, q, pole) = samples[k];
|
||||
let (a, b) = (samples[k.saturating_sub(1)].0, samples[(k + 1).min(samples.len() - 1)].0);
|
||||
for d in 0..2 {
|
||||
// Next to a pole the parameter it collapses is no function of the point: a
|
||||
// meridian's angle there is rounding, not an extreme.
|
||||
let near_pole = |j: Option<usize>| j.and_then(|j| samples.get(j)).is_some_and(|s| s.2[d]);
|
||||
if pole[d] || near_pole(k.checked_sub(1)) || near_pole(Some(k + 1)) {
|
||||
continue;
|
||||
}
|
||||
let side = |j: usize| samples.get(j).map(|s| s.1[d]);
|
||||
let (before, after) = (if k > 0 { side(k - 1) } else { None }, side(k + 1));
|
||||
for sign in [1.0, -1.0] {
|
||||
// Not lower than either neighbour and higher than one (a level run, a
|
||||
// seam's constant angle, has no extreme between its samples).
|
||||
let higher = |x: Option<f64>| x.is_none_or(|x| sign * q[d] >= sign * x);
|
||||
let above = |x: Option<f64>| x.is_some_and(|x| sign * q[d] > sign * x);
|
||||
if !(higher(before) && higher(after) && (above(before) || above(after))) {
|
||||
continue;
|
||||
}
|
||||
let f = |t: f64| at(t, Some(q)).map_or(f64::NEG_INFINITY, |p| sign * p[d]);
|
||||
let x = sign * golden_max(&f, a.min(b), a.max(b));
|
||||
l_lo[d] = l_lo[d].min(x);
|
||||
l_hi[d] = l_hi[d].max(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for d in 0..2 {
|
||||
|
||||
@@ -829,3 +829,17 @@ fn a_hole_beside_the_seam_lies_in_its_face_turn() {
|
||||
assert!(hole_u > u[0] && hole_u + (a1 - a0) < u[1], "the hole in the turn: {u:?}");
|
||||
assert!(v[0].abs() < 1e-9 && (v[1] - h).abs() < 1e-9, "{v:?}");
|
||||
}
|
||||
|
||||
/// A face's box reaches its boundary's extremes, not its samples' nearest ones: an ellipse cut
|
||||
/// from a cylinder of radius 20 by a plane at 45 degrees rises 20 above its centre, at an angle
|
||||
/// between the points the box is sampled at. Short of it, the face's NURBS form stopped below the
|
||||
/// edge (#4598: the bore of a re-imported rod ended 2.3e-4 short of where it meets the rod).
|
||||
#[test]
|
||||
fn a_face_box_reaches_its_boundary_extremes() {
|
||||
let r = 20.0f64;
|
||||
let cylinder = Surface::Cylinder { frame: Frame { origin: [0.; 3], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] }, radius: r };
|
||||
let c = std::f64::consts::FRAC_1_SQRT_2;
|
||||
let cut = Curve::Ellipse { frame: Frame { origin: [0., 0., 30.], x_axis: [c, 0., c], y_axis: [0., 1., 0.] }, radii: [r * 2f64.sqrt(), r] };
|
||||
let [_, v] = form::extent(&cylinder, &[vec![(&cut, [0.1, 0.1 + TAU], true)]]).expect("an extent");
|
||||
assert!((v[0] - 10.0).abs() < 1e-9 && (v[1] - 50.0).abs() < 1e-9, "{v:?}");
|
||||
}
|
||||
+23
-17
@@ -230,15 +230,17 @@ fn radius_step(radius: f64) -> f64 {
|
||||
}
|
||||
|
||||
/// The largest radius below `radius` (to three significant digits) at which the fillet of
|
||||
/// these edges works, with its result; `None` when none does. Each candidate is a real fillet
|
||||
/// these edges works, with its result; `Ok(None)` when none does. Each candidate is a real fillet
|
||||
/// of the edges, so the radius returned is one that was built; the search runs up to 16 of
|
||||
/// them, so it is for an explicit request, not every refusal.
|
||||
pub fn fillet_max(body: &Body, edges: &[Vec3], radius: f64) -> Option<(f64, Body)> {
|
||||
/// them, so it is for an explicit request, not every refusal. Only a refusal as too large
|
||||
/// ([`KernelError::TooLarge`]) narrows the search: any other failure of a candidate is the
|
||||
/// search's error, since a smaller radius would not be the largest that fits.
|
||||
pub fn fillet_max(body: &Body, edges: &[Vec3], radius: f64) -> Result<Option<(f64, Body)>> {
|
||||
if !(radius.is_finite() && radius > 1e-6) {
|
||||
return None;
|
||||
return Ok(None);
|
||||
}
|
||||
let q = radius_step(radius);
|
||||
// Radii n·q for n in [0, hi): hi fails (it is the request, or above it), lo works.
|
||||
// Radii n·q for n in [0, hi): hi is too large (it is the request, or above it), lo works.
|
||||
let mut hi = (radius / q).ceil() as u64;
|
||||
let mut lo = 0u64;
|
||||
let mut best: Option<Body> = None;
|
||||
@@ -253,22 +255,24 @@ pub fn fillet_max(body: &Body, edges: &[Vec3], radius: f64) -> Option<(f64, Body
|
||||
lo = mid;
|
||||
best = Some(b);
|
||||
}
|
||||
Err(_) => hi = mid,
|
||||
Err(KernelError::TooLarge(_)) => hi = mid,
|
||||
Err(e) => return Err(e),
|
||||
}
|
||||
}
|
||||
best.map(|b| (lo as f64 * q, b))
|
||||
Ok(best.map(|b| (lo as f64 * q, b)))
|
||||
}
|
||||
|
||||
/// [`fillet_max`] for each group of the edges that may limit each other's radius (sharing a
|
||||
/// face or a vertex, directly or through other edges in the group), so a round that fits isn't
|
||||
/// reduced for a tight edge elsewhere. The radius per edge (in `edges`' order) and the result;
|
||||
/// one radius for all (as [`fillet_max`]) when a group is refused for another reason than its
|
||||
/// size, the groups don't build together, or there are too many to search (each search is up
|
||||
/// to 16 fillets, and this runs in the live preview).
|
||||
pub fn fillet_max_each(body: &Body, edges: &[Vec3], radius: f64) -> Option<(Vec<f64>, Body)> {
|
||||
/// reduced for a tight edge elsewhere. The radius per edge (in `edges`' order) and the result,
|
||||
/// `Ok(None)` when no radius fits. One radius for all (as [`fillet_max`]) when the groups,
|
||||
/// each reduced to fit, are too large together, or there are too many to search (each search is
|
||||
/// up to 16 fillets, and this runs in the live preview). Any failure other than a refusal as too
|
||||
/// large is the error.
|
||||
pub fn fillet_max_each(body: &Body, edges: &[Vec3], radius: f64) -> Result<Option<(Vec<f64>, Body)>> {
|
||||
const MAX_GROUPS: usize = 8;
|
||||
const MAX_SEARCHES: usize = 2;
|
||||
let one = || fillet_max(body, edges, radius).map(|(r, b)| (vec![r; edges.len()], b));
|
||||
let one = || -> Result<Option<(Vec<f64>, Body)>> { Ok(fillet_max(body, edges, radius)?.map(|(r, b)| (vec![r; edges.len()], b))) };
|
||||
let Some(groups) = interacting_groups(body, edges).filter(|g| g.len() > 1 && g.len() <= MAX_GROUPS) else { return one() };
|
||||
let mut radii = vec![radius; edges.len()];
|
||||
let mut searches = 0;
|
||||
@@ -278,12 +282,13 @@ pub fn fillet_max_each(body: &Body, edges: &[Vec3], radius: f64) -> Option<(Vec<
|
||||
Ok(_) => continue,
|
||||
Err(KernelError::TooLarge(_)) if searches < MAX_SEARCHES => {
|
||||
searches += 1;
|
||||
match fillet_max(body, &pts, radius) {
|
||||
match fillet_max(body, &pts, radius)? {
|
||||
Some((r, _)) => r,
|
||||
None => return one(),
|
||||
}
|
||||
}
|
||||
Err(_) => return one(),
|
||||
Err(KernelError::TooLarge(_)) => return one(),
|
||||
Err(e) => return Err(e),
|
||||
};
|
||||
for i in g {
|
||||
if let Some(x) = radii.get_mut(*i) {
|
||||
@@ -292,8 +297,9 @@ pub fn fillet_max_each(body: &Body, edges: &[Vec3], radius: f64) -> Option<(Vec<
|
||||
}
|
||||
}
|
||||
match fillet_each(body, edges, &radii) {
|
||||
Ok(b) => Some((radii, b)),
|
||||
Err(_) => one(),
|
||||
Ok(b) => Ok(Some((radii, b))),
|
||||
Err(KernelError::TooLarge(_)) => one(),
|
||||
Err(e) => Err(e),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -361,6 +361,54 @@ fn surfaces_in_separate_groups_remain_separate_parts() {
|
||||
}
|
||||
}
|
||||
|
||||
/// The box of [`trimmed_surfaces_sew_into_a_solid`] with its edge (0, 0, 0)–(0, 20, 0) stopping
|
||||
/// 0.01 mm short of its corner in both faces that use it, its next pieces starting at the
|
||||
/// corner. The pieces of a trim curve run on from one another, so the edge ends at the corner the
|
||||
/// other three edges there agree on, exactly: a closed box SMLib finds valid. The edge was left
|
||||
/// short with the gap on the vertex's tolerance, 2000 times the file's resolution (#3845).
|
||||
#[test]
|
||||
fn trim_pieces_that_miss_their_corner_are_closed_onto_it() {
|
||||
let c =
|
||||
|i: usize| -> [f64; 3] { [if i & 1 != 0 { 10.0 } else { 0.0 }, if i & 2 != 0 { 20.0 } else { 0.0 }, if i & 4 != 0 { 30.0 } else { 0.0 }] };
|
||||
let short = [0.0, 19.99, 0.0];
|
||||
let quads = [[0, 2, 3, 1], [4, 5, 7, 6], [0, 1, 5, 4], [2, 6, 7, 3], [0, 4, 6, 2], [1, 3, 7, 5]];
|
||||
let mut ents: Vec<(i64, i64, String)> = Vec::new();
|
||||
let fmt = |p: [f64; 3]| format!("{:?},{:?},{:?}", p[0], p[1], p[2]);
|
||||
for q in quads {
|
||||
let (a, b, cc, d) = (c(q[0]), c(q[1]), c(q[2]), c(q[3]));
|
||||
let surf = format!("1,1,1,1,0,0,1,0,0,0.,0.,1.,1.,0.,0.,1.,1.,1.,1.,1.,1.,{},{},{},{},0.,1.,0.,1.", fmt(a), fmt(b), fmt(d), fmt(cc));
|
||||
ents.push((128, 0, surf));
|
||||
let s_de = 2 * ents.len() - 1;
|
||||
let mut lines = Vec::new();
|
||||
for (p0, p1) in [(a, b), (b, cc), (cc, d), (d, a)] {
|
||||
// The short edge: its end at (0, 20, 0) is 0.01 short.
|
||||
let (p0, p1) = match (p0, p1) {
|
||||
([0.0, 0.0, 0.0], [0.0, 20.0, 0.0]) => (p0, short),
|
||||
([0.0, 20.0, 0.0], [0.0, 0.0, 0.0]) => (short, p1),
|
||||
x => x,
|
||||
};
|
||||
ents.push((110, 0, format!("{},{}", fmt(p0), fmt(p1))));
|
||||
lines.push(2 * ents.len() - 1);
|
||||
}
|
||||
ents.push((102, 0, format!("4,{}", lines.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(","))));
|
||||
let comp = 2 * ents.len() - 1;
|
||||
ents.push((142, 0, format!("0,{s_de},0,{comp},2")));
|
||||
let cos = 2 * ents.len() - 1;
|
||||
ents.push((144, 0, format!("{s_de},1,0,{cos}")));
|
||||
}
|
||||
let imp = iges_import(&iges_file(&ents)).unwrap();
|
||||
assert!(imp.warnings.is_empty(), "{:?}", imp.warnings);
|
||||
assert!(imp.bodies[0].closed);
|
||||
let body = &imp.bodies[0].body;
|
||||
let check = body.smlib().unwrap().check(solidcraft_smlib::CheckLevel::All).unwrap();
|
||||
assert!(check.is_valid(), "{check}");
|
||||
for v in &body.record().vertices {
|
||||
assert!(v.tolerance <= body.record().tolerance, "a vertex {:?} kept a gap in its tolerance {}", v.point, v.tolerance);
|
||||
}
|
||||
let m = measure(body).unwrap();
|
||||
assert!(rel(m.volume, 6000.0) < 1e-6 && rel(m.area, 2200.0) < 1e-6, "{} {}", m.volume, m.area);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_drill_point_round_trips_through_iges() {
|
||||
// A blind hole with a cone tip: the tip's face closes at its apex (its seam runs out to the
|
||||
|
||||
@@ -357,14 +357,14 @@ fn fillet_max_finds_the_largest_radius_that_works() {
|
||||
let b = box_solid(Vec3::new(14.0, 0.0, 0.0), Vec3::new(28.0, 6.0, 10.0)).unwrap();
|
||||
let mids = [Vec3::new(14.0, 0.0, 5.0), Vec3::new(28.0, 0.0, 5.0), Vec3::new(14.0, 6.0, 5.0), Vec3::new(28.0, 6.0, 5.0)];
|
||||
assert!(too_large(&b, &mids, 3.5));
|
||||
let (r, body) = fillet_max(&b, &mids, 3.5).unwrap();
|
||||
let (r, body) = fillet_max(&b, &mids, 3.5).unwrap().unwrap();
|
||||
assert_eq!(r, 3.0);
|
||||
assert!(rel(measure(&body).unwrap().volume, 840.0 - (4.0 - PI) * 90.0) < 2e-4);
|
||||
// A 2 mm disc's top edge: up to 2 (the wall used up).
|
||||
let disc = cylinder(Vec3::ZERO, Vec3::Z, 13.0, 2.0).unwrap();
|
||||
let top = [Vec3::new(0.0, 13.0, 2.0), Vec3::new(0.0, -13.0, 2.0)];
|
||||
assert!(too_large(&disc, &top, 2.5));
|
||||
assert_eq!(fillet_max(&disc, &top, 2.5).map(|x| x.0), Some(2.0));
|
||||
assert_eq!(fillet_max(&disc, &top, 2.5).unwrap().map(|x| x.0), Some(2.0));
|
||||
// Walls of different heights: at the shortest one's height only that wall would be used up,
|
||||
// which is refused, so the largest radius is just below it (to the search's 3 digits).
|
||||
let notched = boolean(
|
||||
@@ -376,10 +376,13 @@ fn fillet_max_finds_the_largest_radius_that_works() {
|
||||
.unwrap();
|
||||
let outline = [Vec3::new(20.0, 0.0, 10.0), Vec3::new(40.0, 15.0, 10.0), Vec3::new(20.0, 30.0, 10.0), Vec3::new(0.0, 15.0, 10.0)];
|
||||
assert!(too_large(¬ched, &outline, 8.0));
|
||||
let (r, _) = fillet_max(¬ched, &outline, 8.0).unwrap();
|
||||
let (r, _) = fillet_max(¬ched, &outline, 8.0).unwrap().unwrap();
|
||||
assert!((r - 6.999).abs() < 1e-9, "{r}");
|
||||
// No edge there: no radius.
|
||||
assert!(fillet_max(&b, &[Vec3::new(500.0, 0.0, 5.0)], 1.0).is_none());
|
||||
// No edge there: the fillet's own error, not a smaller radius (only a refusal as too large
|
||||
// narrows the search).
|
||||
let e = fillet(&b, &[Vec3::new(500.0, 0.0, 5.0)], 1.0).unwrap_err();
|
||||
assert!(!matches!(e, KernelError::TooLarge(_)), "{e}");
|
||||
assert_eq!(fillet_max(&b, &[Vec3::new(500.0, 0.0, 5.0)], 1.0).unwrap_err().to_string(), e.to_string());
|
||||
}
|
||||
|
||||
/// Edges that share no face get their own largest radius: a 2 mm fin's top edge takes at most
|
||||
@@ -401,7 +404,7 @@ fn fillet_max_each_reduces_only_where_the_radius_does_not_fit() {
|
||||
// at its edge less the quarter disc about (17, 26), inside the fin (x >= 19): 2 x 4 less the
|
||||
// disc's part, in closed form; the corner's round (1 − π/4)·16 along 20.
|
||||
let both = fillet(&body, &edges, 4.0).unwrap();
|
||||
let (radii, b) = fillet_max_each(&body, &edges, 4.0).unwrap();
|
||||
let (radii, b) = fillet_max_each(&body, &edges, 4.0).unwrap().unwrap();
|
||||
assert_eq!(radii, vec![4.0, 4.0], "{radii:?}");
|
||||
assert!(b.validity().is_empty(), "{:?}", b.validity());
|
||||
let disc = |a: f64| 0.5 * (a * (16.0 - a * a).max(0.0).sqrt() + 16.0 * (a / 4.0).asin());
|
||||
@@ -412,7 +415,7 @@ fn fillet_max_each_reduces_only_where_the_radius_does_not_fit() {
|
||||
// The post's four edges limit each other: one radius, as `fillet_max`.
|
||||
let post = box_solid(Vec3::new(14.0, 0.0, 0.0), Vec3::new(28.0, 6.0, 10.0)).unwrap();
|
||||
let mids = [Vec3::new(14.0, 0.0, 5.0), Vec3::new(28.0, 0.0, 5.0), Vec3::new(14.0, 6.0, 5.0), Vec3::new(28.0, 6.0, 5.0)];
|
||||
assert_eq!(fillet_max_each(&post, &mids, 3.5).map(|x| x.0), Some(vec![3.0; 4]));
|
||||
assert_eq!(fillet_max_each(&post, &mids, 3.5).unwrap().map(|x| x.0), Some(vec![3.0; 4]));
|
||||
}
|
||||
|
||||
/// A corner's rounds too large for its faces are refused as too large, so a fit can reduce
|
||||
@@ -426,7 +429,7 @@ fn corner_rounds_larger_than_their_faces_are_too_large() {
|
||||
// blend can't find it; the corner build is what says the radius is too large.
|
||||
let e = fillet(&b, &corner, l).unwrap_err();
|
||||
assert!(matches!(e, KernelError::TooLarge(_)), "{e}");
|
||||
let (r, body) = fillet_max(&b, &corner, l).unwrap();
|
||||
let (r, body) = fillet_max(&b, &corner, l).unwrap().unwrap();
|
||||
assert!((r - 19.99).abs() < eps, "{r}");
|
||||
assert!(body.validity().is_empty(), "{:?}", body.validity());
|
||||
// Three rounds along the edges past the corner cube, and the cube less its sphere octant.
|
||||
|
||||
@@ -167,6 +167,7 @@ impl Builder<'_, '_> {
|
||||
if periods.iter().all(Option::is_none) {
|
||||
continue;
|
||||
}
|
||||
let found = axis(&surface).or_else(|| spline_axis(&surface, &eval));
|
||||
let mut up = Vec::new();
|
||||
let mut down = Vec::new();
|
||||
for (li, l) in face.loops.iter().enumerate() {
|
||||
@@ -175,6 +176,12 @@ impl Builder<'_, '_> {
|
||||
if w[1] != 0 || w[0].abs() > 1 {
|
||||
return Err(format!("face #{}: {}", face.step, unsupported("a loop winding around a surface more than once or in v")));
|
||||
}
|
||||
// A loop through a pole turns once round the axis and closes there, where every
|
||||
// angle is one point: a cone's base circle with its seam out to the apex and
|
||||
// back. It has its seam; another one doubled it, a sliver the face crossed.
|
||||
if w[0] != 0 && found.as_ref().is_some_and(|ax| self.through_pole(es, ax)) {
|
||||
continue;
|
||||
}
|
||||
match w[0] {
|
||||
1 => up.push(li),
|
||||
-1 => down.push(li),
|
||||
@@ -185,7 +192,7 @@ impl Builder<'_, '_> {
|
||||
continue;
|
||||
}
|
||||
let step = face.step;
|
||||
let Some(ax) = axis(&surface).or_else(|| spline_axis(&surface, &eval)) else {
|
||||
let Some(ax) = found else {
|
||||
return Err(format!("face #{step}: {}", unsupported("a face winding around a torus or a spline closed in v without a seam edge")));
|
||||
};
|
||||
match (up.as_slice(), down.as_slice()) {
|
||||
@@ -226,6 +233,15 @@ impl Builder<'_, '_> {
|
||||
Ok(total.map(|x| x.round() as i64))
|
||||
}
|
||||
|
||||
/// A vertex of the loop is on one of the axis's poles (within its tolerance).
|
||||
fn through_pole(&self, es: &[(u32, bool)], ax: &Axis) -> bool {
|
||||
es.iter().any(|&u| {
|
||||
self.start(u).ok().and_then(|v| self.vertices.get(v as usize)).is_some_and(|x| {
|
||||
ax.poles.iter().flatten().any(|p| Vec3::from(x.point).dist(*p) <= self.tol.max(x.tolerance))
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
/// The vertex where use `k` of a loop starts.
|
||||
fn start(&self, (e, forward): (u32, bool)) -> R<u32> {
|
||||
let edge = self.edges.get(e as usize).ok_or("edge reference")?;
|
||||
|
||||
@@ -445,6 +445,35 @@ fn a_cone_reaches_its_apex_through_a_vertex_loop() {
|
||||
faces_away(&s.brep, 0, |p| [0.0, 0.0, p[2].clamp(1.0, 2.0)]);
|
||||
}
|
||||
|
||||
/// The same cone written with its seam: the base circle, then the seam out to the apex and back.
|
||||
/// The loop turns once round the axis and closes at the apex, so it has its seam; reading it as
|
||||
/// a loop without one gave the face a second seam, a sliver out and back the face's boundary
|
||||
/// crossed (#5193: a turned pin's drill point after a STEP round trip did not tessellate).
|
||||
#[test]
|
||||
fn a_cone_with_its_seam_to_the_apex_gets_no_other() {
|
||||
let mut w = W::default();
|
||||
let (p, top) = ([5.0, 0.0, 0.0], [0.0, 0.0, 10.0]);
|
||||
let (v, apex) = (w.vertex(p), w.vertex(top));
|
||||
let k = w.circle([0.0; 3], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0], 5.0);
|
||||
let e = w.add(format!("EDGE_CURVE('',#{v},#{v},#{k},.T.)"));
|
||||
let seam = w.line_edge((v, p), (apex, top), true, len3(sub3(top, p)));
|
||||
let a = w.axis([0.0; 3], [0.0, 0.0, -1.0], [1.0, 0.0, 0.0]);
|
||||
let cone = w.add(format!("CONICAL_SURFACE('',#{a},5.,{})", real(0.5f64.atan())));
|
||||
let uses = [w.oe(e, true), w.oe(seam, true), w.oe(seam, false)];
|
||||
let outer = w.bound(&uses, true, true);
|
||||
let side = w.face(&[outer], cone, true);
|
||||
let o = w.oe(e, false);
|
||||
let base_bound = w.bound(&[o], true, true);
|
||||
let plane = w.plane([0.0; 3], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]);
|
||||
let base = w.face(&[base_bound], plane, false);
|
||||
let shell = closed_shell(&mut w, &[side, base]);
|
||||
let solid = w.add(format!("MANIFOLD_SOLID_BREP('cone',#{shell})"));
|
||||
let s = one_solid(&w.file(&[solid]));
|
||||
assert_eq!(counts(&s.brep), [2, 1, 2, 2, 2]);
|
||||
assert!(!s.notes.iter().any(|n| n.contains("seam edges added")), "{:?}", s.notes);
|
||||
faces_away(&s.brep, 0, |p| [0.0, 0.0, p[2].clamp(1.0, 2.0)]);
|
||||
}
|
||||
|
||||
/// A tube (radius 5 outside, 3 inside, from z = 0 to 4) whose cylinders carry no seam edges:
|
||||
/// each side is bounded by two circles whose vertices sit at different angles.
|
||||
#[test]
|
||||
|
||||
Reference in new issue
Block a user