Wave 399/509: STEP import: a void reads as a cavity whichever way its shell flag points, again (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - f8b45f277 jyviko: STEP import: a void reads as a cavity whichever way its shell flag points, again - 64188ce43 jyviko: Planar regions: a hole goes to the material that holds it, read closer than the hole lies - 1a0289011 jyviko: Planar region tests: edges on one line are one edge of the result - 514426e5d jyviko: STEP import: a closed spline a face lies across the start of starts clear of the face Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -9,7 +9,7 @@
|
||||
//! Call on validated records. Evaluation of a well-formed record never panics: a point that
|
||||
//! cannot be had (a vanishing weight, a Newton step that does not converge) is `None`.
|
||||
use super::pcurve::Error;
|
||||
use super::{Curve, Frame, Surface};
|
||||
use super::{Curve, Curve2, Frame, Surface};
|
||||
use crate::Vec3;
|
||||
use crate::bspline::MAX_SPLINE_DEGREE;
|
||||
use crate::tess::partials::{Partials, tabulate, trig_derivative};
|
||||
@@ -482,3 +482,50 @@ fn solve3(rows: [Vec3; 3], rhs: [f64; 3]) -> Option<Vec3> {
|
||||
let x = (bc * rhs[0] + ca * rhs[1] + ab * rhs[2]) * (1.0 / det);
|
||||
x.is_finite().then_some(x)
|
||||
}
|
||||
|
||||
/// Four-point Gauss–Legendre nodes and weights on `[−1, 1]`.
|
||||
const GAUSS4: [(f64, f64); 4] = [
|
||||
(-0.861_136_311_594_052_6, 0.347_854_845_137_453_8),
|
||||
(-0.339_981_043_584_856_3, 0.652_145_154_862_546_2),
|
||||
(0.339_981_043_584_856_3, 0.652_145_154_862_546_2),
|
||||
(0.861_136_311_594_052_6, 0.347_854_845_137_453_8),
|
||||
];
|
||||
|
||||
/// Pieces each pcurve is integrated in, and how many Gauss panels cover a v range.
|
||||
const FLUX_PIECES: usize = 32;
|
||||
const FLUX_PANELS: usize = 4;
|
||||
|
||||
/// The flux of `field` through a face, `∫∫ field(S)·(S_u × S_v) du dv` over the (u, v) region its
|
||||
/// loops (record convention, each use its pcurve and direction) bound, by Green's theorem:
|
||||
/// `∮ −G du` with `G(u, v) = ∫ field·N ds` from `v0` to `v`. A quadrature for the sign of a
|
||||
/// shell's volume (`field = p / 3`) or a winding number, which only has to be right to well
|
||||
/// under a half: no geometry is made from it. Loops round a periodic direction need no seam
|
||||
/// edge, as a seam's two runs at constant u add nothing to `∮ G du`.
|
||||
pub fn face_flux(s: &SurfaceEval, v0: f64, loops: &[Vec<(&Curve2, bool)>], field: &dyn Fn(Vec3) -> Vec3) -> Option<f64> {
|
||||
let g = |u: f64, v: f64| -> Option<f64> {
|
||||
let (mut sum, h) = (0.0, (v - v0) / FLUX_PANELS as f64);
|
||||
for panel in 0..FLUX_PANELS {
|
||||
let a = v0 + h * panel as f64;
|
||||
for (x, w) in GAUSS4 {
|
||||
let t = a + 0.5 * h * (x + 1.0);
|
||||
let (p, su, sv) = s.derivs(u, t)?;
|
||||
sum += 0.5 * h * w * field(p).dot(su.cross(sv));
|
||||
}
|
||||
}
|
||||
sum.is_finite().then_some(sum)
|
||||
};
|
||||
let mut total = 0.0;
|
||||
for (c, forward) in loops.iter().flatten() {
|
||||
let [t0, t1] = c.interval()?;
|
||||
let at = |k: f64| {
|
||||
let f = k / FLUX_PIECES as f64;
|
||||
// Exactly the ends at f = 0 and 1, whatever the interval's rounding.
|
||||
c.eval(if *forward { t0 * (1.0 - f) + t1 * f } else { t1 * (1.0 - f) + t0 * f })
|
||||
};
|
||||
for k in 0..FLUX_PIECES {
|
||||
let (a, m, z) = (at(k as f64)?, at(k as f64 + 0.5)?, at(k as f64 + 1.0)?);
|
||||
total -= g(m[0], m[1])? * (z[0] - a[0]);
|
||||
}
|
||||
}
|
||||
total.is_finite().then_some(total)
|
||||
}
|
||||
|
||||
+22
-10
@@ -260,7 +260,7 @@ mod sheets {
|
||||
let mid = hole.segs.first().map(|s| s.point_at(0.5)).ok_or_else(|| failed("face", format!("face {f} has an empty loop")))?;
|
||||
let owner = out[first..]
|
||||
.iter_mut()
|
||||
.filter(|r| r.outer.contains(mid))
|
||||
.filter(|r| holds(&r.outer, mid))
|
||||
.min_by(|a, b| a.outer.signed_area().total_cmp(&b.outer.signed_area()))
|
||||
.ok_or_else(|| failed("face", format!("face {f} has a hole outside its material")))?;
|
||||
owner.holes.push(hole);
|
||||
@@ -269,6 +269,15 @@ mod sheets {
|
||||
Ok(Regions { regions: out, touching })
|
||||
}
|
||||
|
||||
/// Whether the loop `outer` holds `p`: even-odd against its polyline within a quarter of
|
||||
/// `p`'s distance from it, so the polyline's chords cannot pass `p` by (a loop's own
|
||||
/// [`Loop2::contains`] reads it within 1e-3 mm, and a hole closer than that to an arc of the
|
||||
/// outline was taken for one outside it, a chord cutting it off).
|
||||
fn holds(outer: &Loop2, p: Vec2) -> bool {
|
||||
let d = outer.segs.iter().map(|s| s.point_at(s.closest_param(p)).dist(p)).fold(f64::INFINITY, f64::min);
|
||||
outer.polyline((d * 0.25).clamp(1e-9, 1e-3)).contains(p)
|
||||
}
|
||||
|
||||
/// The natural normal of a planar surface record.
|
||||
fn natural_normal(s: &Surface) -> Option<Vec3> {
|
||||
let v = |p: [f64; 3]| Vec3::new(p[0], p[1], p[2]);
|
||||
@@ -476,8 +485,8 @@ mod planar_tests {
|
||||
/// Two edges lying on one another within the tolerance, a hair from parallel, meet at a
|
||||
/// point somewhere along their overlap. Taken for a crossing, that point split the square's
|
||||
/// edge once more: 5e-8 mm before its end, which left an edge shorter than the tolerance in
|
||||
/// the result, or in the middle of a straight edge. The ends of an overlap are what split
|
||||
/// the edges.
|
||||
/// the result, or in the middle of a straight edge. Edges on one line within the tolerance
|
||||
/// are one edge of the result: where they meet is no corner.
|
||||
#[test]
|
||||
fn overlapping_lines_a_hair_from_parallel_do_not_cross() {
|
||||
let square = rectangle(Vec2::ZERO, Vec2::new(10.0, 10.0));
|
||||
@@ -498,20 +507,22 @@ mod planar_tests {
|
||||
};
|
||||
let same = |got: &[f64], want: &[f64]| got.len() == want.len() && got.iter().zip(want).all(|(g, w)| (g - w).abs() < 1e-6);
|
||||
for meet in [10.0 - 5e-8, 7.0] {
|
||||
// Below the square, against its bottom edge: cut away, it leaves the square, the
|
||||
// bottom edge split only at x = 4, where the quadrilateral's corner lies on it.
|
||||
// Below the square, against its bottom edge: cut away, it leaves the square, its four
|
||||
// edges whole (the quadrilateral's corner at x = 4 lies within 1e-8 of the bottom
|
||||
// edge, on its line, and its edge from there is no more than 1e-8 off it).
|
||||
let below = quad(meet, -5.0);
|
||||
let cut = planar_regions_boolean(std::slice::from_ref(&square), std::slice::from_ref(&below), BoolOp::Cut, 1e-7).unwrap();
|
||||
assert_eq!(cut.len(), 1, "{meet}");
|
||||
assert!(same(&lengths(&cut[0]), &[4.0, 6.0, 10.0, 10.0, 10.0]), "{meet}: cut edges {:?}", lengths(&cut[0]));
|
||||
assert!(same(&lengths(&cut[0]), &[10.0, 10.0, 10.0, 10.0]), "{meet}: cut edges {:?}", lengths(&cut[0]));
|
||||
assert!((cut[0].area() - 100.0).abs() < 1e-6, "{meet}: {}", cut[0].area());
|
||||
// Over the square, flush with that edge and reaching past it to x = 14: the
|
||||
// union's outline runs along y = 0 once, in the pieces 0..4, 4..10 and 10..14.
|
||||
// union's outline runs along y = 0 once, one edge from 0 to 14 (the quadrilateral's
|
||||
// bottom edge lies within 1e-8 of the line y = 0 all along).
|
||||
let flush = quad(meet, 5.0);
|
||||
let union = planar_regions_boolean(std::slice::from_ref(&square), std::slice::from_ref(&flush), BoolOp::Union, 1e-7)
|
||||
.unwrap_or_else(|e| panic!("{meet}: union {e}"));
|
||||
assert_eq!(union.len(), 1, "{meet}");
|
||||
assert!(same(&lengths(&union[0]), &[4.0, 4.0, 4.0, 5.0, 5.0, 6.0, 10.0, 10.0]), "{meet}: union edges {:?}", lengths(&union[0]));
|
||||
assert!(same(&lengths(&union[0]), &[4.0, 5.0, 5.0, 10.0, 10.0, 14.0]), "{meet}: union edges {:?}", lengths(&union[0]));
|
||||
assert!((union[0].area() - 120.0).abs() < 1e-6, "{meet}: {}", union[0].area());
|
||||
}
|
||||
}
|
||||
@@ -597,7 +608,8 @@ mod planar_tests {
|
||||
/// there left a sliver of edge shorter than the distance within which the loops join their
|
||||
/// pieces; the chaining took it for a second way out of the corner, and a loop of that one
|
||||
/// sliver is open, its area not zero away from the origin: a hole no outline held (no
|
||||
/// result at all) or a region of its own. The union is the plate and the strip, whole.
|
||||
/// result at all) or a region of its own. The union is the plate and the strip, whole: six
|
||||
/// edges, the strip's end and the plate's on the line x = 150 one edge from y = 47 to 80.
|
||||
#[test]
|
||||
fn a_bent_edge_crossing_its_neighbour_by_their_corner_leaves_no_sliver() {
|
||||
let union_is_whole = |(plate, strip): (Region2, Region2), what: &str| {
|
||||
@@ -608,7 +620,7 @@ mod planar_tests {
|
||||
assert_eq!(out.len(), 1, "{what}: {out:?}");
|
||||
let lp = &out[0].outer;
|
||||
let shortest = lp.segs.iter().map(Seg2::length).fold(f64::MAX, f64::min);
|
||||
assert!(out[0].holes.is_empty() && lp.segs.len() == 7 && shortest > 2.9, "{what}: {} edges, shortest {shortest:e}", lp.segs.len());
|
||||
assert!(out[0].holes.is_empty() && lp.segs.len() == 6 && shortest > 2.9, "{what}: {} edges, shortest {shortest:e}", lp.segs.len());
|
||||
assert!((out[0].area() - want).abs() < 1e-6, "{what}: {} vs {want}", out[0].area());
|
||||
}
|
||||
};
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
use solidcraft_geom::brep::eval::SurfaceEval;
|
||||
use solidcraft_geom::brep::eval::{SurfaceEval, face_flux};
|
||||
use solidcraft_geom::brep::{self as b, Curve2, pcurve};
|
||||
use solidcraft_geom::{Ring, Vec3};
|
||||
|
||||
@@ -1650,53 +1650,6 @@ fn domain_of(surface: &b::Surface, pcs: &[Vec<Curve2>]) -> Option<[[f64; 2]; 2]>
|
||||
Some(out)
|
||||
}
|
||||
|
||||
/// Four-point Gauss–Legendre nodes and weights on `[−1, 1]`.
|
||||
const GAUSS4: [(f64, f64); 4] = [
|
||||
(-0.861_136_311_594_052_6, 0.347_854_845_137_453_8),
|
||||
(-0.339_981_043_584_856_3, 0.652_145_154_862_546_2),
|
||||
(0.339_981_043_584_856_3, 0.652_145_154_862_546_2),
|
||||
(0.861_136_311_594_052_6, 0.347_854_845_137_453_8),
|
||||
];
|
||||
|
||||
/// Pieces each pcurve is integrated in, and how many Gauss panels cover a v range.
|
||||
const FLUX_PIECES: usize = 32;
|
||||
const FLUX_PANELS: usize = 4;
|
||||
|
||||
/// The flux of `field` through a face, `∫∫ field(S)·(S_u × S_v) du dv` over the (u, v) region its
|
||||
/// loops (record convention, each use its pcurve and direction) bound, by Green's theorem:
|
||||
/// `∮ −G du` with `G(u, v) = ∫ field·N ds` from `v0` to `v`. A quadrature for the sign of a
|
||||
/// shell's volume (`field = p / 3`) or a winding number, which only has to be right to well
|
||||
/// under a half: no geometry is made from it. Loops round a periodic direction need no seam
|
||||
/// edge, as a seam's two runs at constant u add nothing to `∮ G du`.
|
||||
fn face_flux(s: &SurfaceEval, v0: f64, loops: &[Vec<(&Curve2, bool)>], field: &dyn Fn(Vec3) -> Vec3) -> Option<f64> {
|
||||
let g = |u: f64, v: f64| -> Option<f64> {
|
||||
let (mut sum, h) = (0.0, (v - v0) / FLUX_PANELS as f64);
|
||||
for panel in 0..FLUX_PANELS {
|
||||
let a = v0 + h * panel as f64;
|
||||
for (x, w) in GAUSS4 {
|
||||
let t = a + 0.5 * h * (x + 1.0);
|
||||
let (p, su, sv) = s.derivs(u, t)?;
|
||||
sum += 0.5 * h * w * field(p).dot(su.cross(sv));
|
||||
}
|
||||
}
|
||||
sum.is_finite().then_some(sum)
|
||||
};
|
||||
let mut total = 0.0;
|
||||
for (c, forward) in loops.iter().flatten() {
|
||||
let [t0, t1] = c.interval()?;
|
||||
let at = |k: f64| {
|
||||
let f = k / FLUX_PIECES as f64;
|
||||
// Exactly the ends at f = 0 and 1, whatever the interval's rounding.
|
||||
c.eval(if *forward { t0 * (1.0 - f) + t1 * f } else { t1 * (1.0 - f) + t0 * f })
|
||||
};
|
||||
for k in 0..FLUX_PIECES {
|
||||
let (a, m, z) = (at(k as f64)?, at(k as f64 + 0.5)?, at(k as f64 + 1.0)?);
|
||||
total -= g(m[0], m[1])? * (z[0] - a[0]);
|
||||
}
|
||||
}
|
||||
total.is_finite().then_some(total)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -38,7 +38,7 @@ use std::collections::{HashMap, HashSet};
|
||||
use std::f64::consts::TAU;
|
||||
|
||||
use solidcraft_geom::Vec3;
|
||||
use solidcraft_geom::brep::eval::{CurveEval, SurfaceEval};
|
||||
use solidcraft_geom::brep::eval::{CurveEval, SurfaceEval, face_flux};
|
||||
use solidcraft_geom::brep::pcurve::{self, EdgeUse, TrimEdge, TrimFace, TrimUse, Trims};
|
||||
use solidcraft_geom::brep::{
|
||||
self, Brep, Curve as BCurve, Curve2, Edge, EdgeUseRef, Face, Frame, Loop, Natural, OrientedEdge, OrientedFace, Region, Shell,
|
||||
@@ -950,6 +950,7 @@ impl<'b, 'a> Builder<'b, 'a> {
|
||||
if at_poles > 0 {
|
||||
notes.push(format!("{at_poles} edges split where they pass through a face's pole"));
|
||||
}
|
||||
self.start_splines_clear_of_faces()?;
|
||||
let seams = self.add_seams()?;
|
||||
if seams > 0 {
|
||||
notes.push(format!("{seams} seam edges added to faces that wind around their surface"));
|
||||
@@ -1033,6 +1034,42 @@ impl<'b, 'a> Builder<'b, 'a> {
|
||||
|
||||
// Regions: which shells are closed (every edge used at least twice among its faces).
|
||||
let closed: Vec<bool> = shells.iter().map(|s| self.closed(s)).collect();
|
||||
// A void's faces face into the cavity, out of the material: it encloses volume of the
|
||||
// opposite sign to the outer shell's. The ORIENTED_CLOSED_SHELL flag alone doesn't say
|
||||
// so: some exporters write .F. over a shell already facing into the cavity (#3730),
|
||||
// SolidCraft .T.; read by the flag, such a void added its cavity's volume to the solid's.
|
||||
// A void enclosing volume of the outer shell's sign is turned inside out, the signs the
|
||||
// faces' own surfaces and pcurves give (`face_flux` of p / 3, the divergence theorem).
|
||||
let shells = if kind == Kind::Voids && closed.iter().all(|c| *c) {
|
||||
let volume = |s: &[(u32, bool)]| -> Option<f64> {
|
||||
let mut sum = 0.0;
|
||||
for &(f, forward) in s {
|
||||
let face = self.faces.get(f as usize)?;
|
||||
let on = face_forms.get(f as usize)?.as_ref().unwrap_or(&face.surface);
|
||||
let eval = SurfaceEval::new(on).ok()?;
|
||||
let edge_loops = face.loops.iter().filter_map(|l| match l {
|
||||
LoopB::Edges(es) => Some(es),
|
||||
LoopB::Vertex(_) => None,
|
||||
});
|
||||
let uses: Vec<Vec<(&Curve2, bool)>> =
|
||||
edge_loops.zip(pcs.get(f as usize)?).map(|(es, pc)| pc.iter().zip(es).map(|(c, (_, fwd))| (c, *fwd)).collect()).collect();
|
||||
let flux = face_flux(&eval, domains.get(f as usize)?[1][0], &uses, &|p| p * (1.0 / 3.0))?;
|
||||
sum += if forward { flux } else { -flux };
|
||||
}
|
||||
sum.is_finite().then_some(sum)
|
||||
};
|
||||
let outside = shells.first().and_then(|s| volume(s));
|
||||
shells
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
.map(|(k, s)| match (outside, k > 0) {
|
||||
(Some(o), true) if volume(&s).is_some_and(|v| v * o > 0.0) => s.into_iter().map(|(f, fwd)| (f, !fwd)).collect(),
|
||||
_ => s,
|
||||
})
|
||||
.collect()
|
||||
} else {
|
||||
shells
|
||||
};
|
||||
let mut regions = vec![Region { shells: Vec::new(), void: false }];
|
||||
match kind {
|
||||
Kind::Solid | Kind::Voids => {
|
||||
|
||||
@@ -151,7 +151,131 @@ fn meridian(profile: &BCurve, o: Vec3, k: Vec3, angle: f64) -> R<BCurve> {
|
||||
})
|
||||
}
|
||||
|
||||
/// A B-spline surface closed around u (its first and last control columns the same, `period`
|
||||
/// its knot width) started at `s` instead, exactly: `s` inserted to full multiplicity, then the
|
||||
/// piece from `s` to the end followed by the piece from the start to `s`, moved on by a period.
|
||||
/// The same points at parameters a period apart before `s`; `None` for another surface or an `s`
|
||||
/// outside the open domain.
|
||||
fn restarted(surface: &BSurface, s: f64, period: f64) -> Option<BSurface> {
|
||||
use solidcraft_geom::bspline::{HPoint, segment};
|
||||
let (u_knots, v_knots, rows): (&Vec<f64>, &Vec<f64>, Vec<Vec<HPoint>>) = match surface {
|
||||
BSurface::Spline { u_knots, v_knots, points } => {
|
||||
(u_knots, v_knots, points.iter().map(|r| r.iter().map(|p| HPoint { x: p[0], y: p[1], z: p[2], w: 1.0 }).collect()).collect())
|
||||
}
|
||||
BSurface::RationalSpline { u_knots, v_knots, homogeneous } => {
|
||||
(u_knots, v_knots, homogeneous.iter().map(|r| r.iter().map(|h| HPoint { x: h[0], y: h[1], z: h[2], w: h[3] }).collect()).collect())
|
||||
}
|
||||
_ => return None,
|
||||
};
|
||||
let n = rows.len();
|
||||
let p = u_knots.len().checked_sub(n + 1)?;
|
||||
let (u0, u1) = (*u_knots.get(p)?, *u_knots.get(n)?);
|
||||
if !(u0 < s && s < u1) || !((u1 - u0 - period).abs() <= 1e-9 * period.max(1.0)) {
|
||||
return None;
|
||||
}
|
||||
// Each v column of control points across u is a curve along u.
|
||||
let columns = rows.first()?.len();
|
||||
let column = |j: usize| rows.iter().map(|r| r.get(j).copied()).collect::<Option<Vec<HPoint>>>();
|
||||
let mut knots: Option<Vec<f64>> = None;
|
||||
let mut out: Vec<Vec<HPoint>> = Vec::with_capacity(columns);
|
||||
for j in 0..columns {
|
||||
let c = column(j)?;
|
||||
let (ka, a) = segment(p, u_knots, &c, s, u1).ok()?;
|
||||
let (kb, b) = segment(p, u_knots, &c, u0, s).ok()?;
|
||||
// The piece after the seam starts where the one before it ends (the closed surface's
|
||||
// last column is its first): joined there with multiplicity p.
|
||||
let mut k = ka.get(..ka.len() - 1)?.to_vec();
|
||||
k.extend(kb.get(p + 1..)?.iter().map(|x| x + period));
|
||||
let mut pts = a;
|
||||
pts.extend(b.get(1..)?.iter().copied());
|
||||
if k.len() != pts.len() + p + 1 || knots.as_ref().is_some_and(|x| *x != k) {
|
||||
return None;
|
||||
}
|
||||
knots = Some(k);
|
||||
out.push(pts);
|
||||
}
|
||||
let u_knots = knots?;
|
||||
// Back to rows along u.
|
||||
let rows: Vec<Vec<HPoint>> =
|
||||
(0..out.first()?.len()).map(|i| out.iter().map(|c| c.get(i).copied()).collect::<Option<Vec<_>>>()).collect::<Option<_>>()?;
|
||||
Some(match surface {
|
||||
BSurface::Spline { .. } => BSurface::Spline {
|
||||
u_knots,
|
||||
v_knots: v_knots.clone(),
|
||||
points: rows.iter().map(|r| r.iter().map(|h| [h.x / h.w, h.y / h.w, h.z / h.w]).collect()).collect(),
|
||||
},
|
||||
_ => BSurface::RationalSpline {
|
||||
u_knots,
|
||||
v_knots: v_knots.clone(),
|
||||
homogeneous: rows.iter().map(|r| r.iter().map(|h| [h.x, h.y, h.z, h.w]).collect()).collect(),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
impl Builder<'_, '_> {
|
||||
/// Start every B-spline surface closed around u that a face lies across the start of, without
|
||||
/// winding round it, in the middle of the widest stretch of u the face leaves free: the face's
|
||||
/// pcurves then run inside the surface's knots, as a kernel's trims have to (one crossing the
|
||||
/// start had its pcurve clamped there, mm off its edge). Exact ([`restarted`]). Returns how
|
||||
/// many surfaces were started anew.
|
||||
pub(super) fn start_splines_clear_of_faces(&mut self) -> R<usize> {
|
||||
let mut turned = 0;
|
||||
for fi in 0..self.faces.len() {
|
||||
let Some(face) = self.faces.get(fi) else { continue };
|
||||
if !matches!(face.surface, BSurface::Spline { .. } | BSurface::RationalSpline { .. }) {
|
||||
continue;
|
||||
}
|
||||
let eval = SurfaceEval::new(&face.surface).map_err(|e| e.to_string())?;
|
||||
let dom = eval.domain();
|
||||
let (Some(period), None, Some((u0, _))) = (dom.period[0], dom.period[1], dom.range[0]) else { continue };
|
||||
// How far along u each loop of the face reaches, followed round from its first point
|
||||
// (unwrapped across the start); a face winding round is the seams' to handle. The
|
||||
// widest loop bounds the face.
|
||||
let mut widest: Option<(f64, f64)> = None;
|
||||
let mut winds = false;
|
||||
for l in &face.loops {
|
||||
let LoopB::Edges(es) = l else { continue };
|
||||
winds |= self.winding(&eval, es, [Some(period), None])?[0] != 0;
|
||||
let mut last: Option<f64> = None;
|
||||
let (mut lo, mut hi) = (f64::INFINITY, f64::NEG_INFINITY);
|
||||
for &(e, _) in es {
|
||||
let edge = self.edges.get(e as usize).ok_or("edge reference")?;
|
||||
let c = CurveEval::new(&edge.curve).map_err(|m| m.to_string())?;
|
||||
let [a, b] = edge.interval;
|
||||
for k in 0..=SAMPLES {
|
||||
let t = a + (b - a) * k as f64 / SAMPLES as f64;
|
||||
let Some(q) = c.point(t).and_then(|p| eval.project(p, None, f64::INFINITY)) else { continue };
|
||||
let u = last.map_or(q[0], |x| x + wrap_by(q[0] - x, period));
|
||||
(lo, hi) = (lo.min(u), hi.max(u));
|
||||
last = Some(u);
|
||||
}
|
||||
}
|
||||
if hi - lo > widest.map_or(f64::NEG_INFINITY, |(a, b)| b - a) {
|
||||
widest = Some((lo, hi));
|
||||
}
|
||||
}
|
||||
let Some((lo, hi)) = widest else { continue };
|
||||
// Across the start: a whole number of periods from it lies inside the reach, clear of
|
||||
// its ends (a face that only meets the start there runs inside the knots already).
|
||||
let start = u0 + ((hi - u0) / period).floor() * period;
|
||||
let clear = 1e-9 * period;
|
||||
let crossing = hi - start > clear && start - lo > clear;
|
||||
if winds || !crossing || !(hi - lo < period) {
|
||||
continue;
|
||||
}
|
||||
// The middle of the stretch the face leaves free.
|
||||
let free = hi + 0.5 * (period - (hi - lo));
|
||||
let at = u0 + (free - u0).rem_euclid(period);
|
||||
let Some(surface) = restarted(&face.surface, at, period) else { continue };
|
||||
if let Some(f) = self.faces.get_mut(fi) {
|
||||
f.surface = surface;
|
||||
f.extent = None;
|
||||
}
|
||||
turned += 1;
|
||||
}
|
||||
Ok(turned)
|
||||
}
|
||||
|
||||
/// Give every face that winds around its surface without a seam one. Returns how many
|
||||
/// seams were added.
|
||||
pub(super) fn add_seams(&mut self) -> R<usize> {
|
||||
|
||||
Reference in New Issue
Block a user