Wave 324/509: Fill: a patch's edges are the body's own edges again, circles and ellipses included (and 3 more)
4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - 9095fce42 jyviko: SMLib export: a NURBS edge's interval a rounding past its knots is the NURBS's own - b68f71a2d jyviko: Fill: a patch's edges are the body's own edges again, circles and ellipses included - b540faaf5 jyviko: Thicken: a surface turned to its back grows the other way again - ebb1d843a jyviko: Sweep: a parallel sweep whose path runs along the profile's plane is refused again Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -214,7 +214,7 @@ fn too_large_or_unsupported_is_refused() {
|
||||
.record()
|
||||
.edges
|
||||
.iter()
|
||||
.filter_map(|e| solidcraft_geom::brep::eval::CurveEval::new(&e.curve).ok()?.point(0.5 * (e.interval[0] + e.interval[1])))
|
||||
.filter_map(|e| solidcraft_geom::brep::eval::CurveEval::new(e.parameters()).ok()?.point(0.5 * (e.interval[0] + e.interval[1])))
|
||||
.find(|m| (m.z - 10.0).abs() < 1e-6)
|
||||
.unwrap();
|
||||
match chamfer_sides(&t, &[rim], 1.0, ChamferSide::Distance(2.0), false) {
|
||||
|
||||
@@ -1379,6 +1379,7 @@ mod tests {
|
||||
let vertices: Vec<[f64; 3]> = corners.iter().map(|&(i, j)| net[j * cu + i]).collect();
|
||||
let edges = (0..4)
|
||||
.map(|k| PartEdge {
|
||||
nurbs: None,
|
||||
curve: b::Curve::Line { start: vertices[k], end: vertices[(k + 1) % 4] },
|
||||
interval: [0.0, 1.0],
|
||||
vertices: [k as u32, ((k + 1) % 4) as u32],
|
||||
|
||||
+14
-10
@@ -709,7 +709,7 @@ fn patch_body(body: &Body, record: &b::Brep, chain: &[(usize, bool)], surface: b
|
||||
})?),
|
||||
Pcurves::Computed => None,
|
||||
};
|
||||
edges.push(PartEdge { curve: edge.parameters().clone(), interval: edge.interval, vertices: ends });
|
||||
edges.push(PartEdge { curve: edge.curve.clone(), nurbs: edge.nurbs.clone(), interval: edge.interval, vertices: ends });
|
||||
uses.push(PartUse { edge: k as u32, forward, given });
|
||||
}
|
||||
if !ccw {
|
||||
@@ -797,9 +797,9 @@ fn quilt_body(body: &Body, record: &b::Brep, chain: &[(usize, bool)], fill: &Iso
|
||||
};
|
||||
}
|
||||
let id = index(edges.len())?;
|
||||
// The curve the interval and the pcurve's parameter are on: a conic's
|
||||
// NURBS form.
|
||||
edges.push(PartEdge { curve: edge.parameters().clone(), interval: [lo, hi], vertices: ends });
|
||||
// The edge itself: the interval and the pcurve's parameter are on its
|
||||
// NURBS form (a conic's), which it keeps.
|
||||
edges.push(PartEdge { curve: edge.curve.clone(), nurbs: edge.nurbs.clone(), interval: [lo, hi], vertices: ends });
|
||||
origin.push(Some(e));
|
||||
piece_of.insert(key, id);
|
||||
id
|
||||
@@ -827,7 +827,7 @@ fn quilt_body(body: &Body, record: &b::Brep, chain: &[(usize, bool)], fill: &Iso
|
||||
b::Curve::Spline { knots: curve.knots.clone(), points: curve.points.iter().map(|p| [p.x, p.y, p.z]).collect() }
|
||||
}
|
||||
};
|
||||
edges.push(PartEdge { curve: spline, interval: [0.0, 1.0], vertices: [start, end] });
|
||||
edges.push(PartEdge { curve: spline, nurbs: None, interval: [0.0, 1.0], vertices: [start, end] });
|
||||
origin.push(None);
|
||||
spoke_of.insert(spoke, id);
|
||||
id
|
||||
@@ -976,11 +976,14 @@ mod tests {
|
||||
worst
|
||||
}
|
||||
|
||||
/// Whether every edge of `made` is one of `of`'s own (the same curve record on the same
|
||||
/// interval).
|
||||
/// Whether every edge of `made` is one of `of`'s own: the same kind of curve, on the same
|
||||
/// curve record it is parameterised on (its NURBS form where it has one), on the same
|
||||
/// interval. (A circle's or ellipse's frame is SMLib's again after a round trip, its axes
|
||||
/// renormalised to the last bit.)
|
||||
fn own_edges(made: &Body, of: &Body) -> bool {
|
||||
let own = record(of).edges;
|
||||
record(made).edges.iter().all(|e| own.iter().any(|o| o.curve == e.curve && o.interval == e.interval))
|
||||
let kind = |e: &b::Edge| std::mem::discriminant(&e.curve);
|
||||
record(made).edges.iter().all(|e| own.iter().any(|o| kind(o) == kind(e) && o.parameters() == e.parameters() && o.interval == e.interval))
|
||||
}
|
||||
|
||||
/// The fill's mesh: every normal finite, and no triangle folded over (all face the same way
|
||||
@@ -1109,9 +1112,10 @@ mod tests {
|
||||
let mut edges = Vec::new();
|
||||
for k in 0..n {
|
||||
let c = &top[k];
|
||||
edges.push(PartEdge { curve: c.clone(), interval: interval(c), vertices: [k as u32, ((k + 1) % n) as u32] });
|
||||
edges.push(PartEdge { curve: moved(c), interval: interval(c), vertices: [(n + k) as u32, (n + (k + 1) % n) as u32] });
|
||||
edges.push(PartEdge { nurbs: None, curve: c.clone(), interval: interval(c), vertices: [k as u32, ((k + 1) % n) as u32] });
|
||||
edges.push(PartEdge { nurbs: None, curve: moved(c), interval: interval(c), vertices: [(n + k) as u32, (n + (k + 1) % n) as u32] });
|
||||
edges.push(PartEdge {
|
||||
nurbs: None,
|
||||
curve: b::Curve::Line { start: arr(corners[k]), end: arr(corners[k] + drop) },
|
||||
interval: [0.0, 1.0],
|
||||
vertices: [k as u32, (n + k) as u32],
|
||||
|
||||
@@ -108,7 +108,7 @@ fn rim_points(body: &Body, per: usize) -> Vec<Vec3> {
|
||||
let r = body.record();
|
||||
let mut out = Vec::new();
|
||||
for e in r.edges.iter().filter(|e| e.uses.len() == 1) {
|
||||
let c = CurveEval::new(&e.curve).unwrap();
|
||||
let c = CurveEval::new(e.parameters()).unwrap();
|
||||
let [t0, t1] = e.interval;
|
||||
for k in 0..per {
|
||||
out.push(c.point(t0 + (t1 - t0) * (k as f64 + 0.5) / per as f64).unwrap());
|
||||
@@ -238,7 +238,7 @@ fn free_edge_points(body: &Body) -> Vec<Vec3> {
|
||||
.edges
|
||||
.iter()
|
||||
.filter(|e| e.uses.len() == 1)
|
||||
.map(|e| CurveEval::new(&e.curve).unwrap().point(0.5 * (e.interval[0] + e.interval[1])).unwrap())
|
||||
.map(|e| CurveEval::new(e.parameters()).unwrap().point(0.5 * (e.interval[0] + e.interval[1])).unwrap())
|
||||
.collect::<Vec<_>>();
|
||||
// In a fixed order.
|
||||
points.sort_by(|a, b| (a.z, a.y, a.x).partial_cmp(&(b.z, b.y, b.x)).unwrap());
|
||||
|
||||
@@ -286,7 +286,7 @@ impl Builder {
|
||||
}
|
||||
};
|
||||
let id = u32::try_from(self.edges.len()).map_err(|_| KernelError::Invalid("sew: edge budget exceeded".into()))?;
|
||||
self.edges.push(PartEdge { curve, interval, vertices: [va, vb] });
|
||||
self.edges.push(PartEdge { nurbs: None, curve, interval, vertices: [va, vb] });
|
||||
self.by_key.insert((ka, fa, kb, fb, mid, sheet), id);
|
||||
Ok((id, true))
|
||||
}
|
||||
@@ -1303,6 +1303,10 @@ pub(crate) struct PartUse {
|
||||
|
||||
pub(crate) struct PartEdge {
|
||||
pub curve: b::Curve,
|
||||
/// The NURBS form the edge is parameterised on, as a record edge keeps it
|
||||
/// ([`b::Edge::nurbs`]): given, `interval` is on it and `curve` only says what the edge is,
|
||||
/// so an edge taken from a record goes back as that same edge.
|
||||
pub nurbs: Option<b::Curve>,
|
||||
pub interval: [f64; 2],
|
||||
pub vertices: [u32; 2],
|
||||
}
|
||||
@@ -1366,8 +1370,8 @@ pub(crate) fn assemble(parts: Parts, solid: bool) -> Result<Assembled> {
|
||||
g
|
||||
};
|
||||
// Each edge's label and NURBS form (`form::edge`): a circle about a revolved face's axis on
|
||||
// that face's frame, so its form lies on the face's quarter grid; an edge the caller gave a
|
||||
// pcurve for keeps the parameter that pcurve is on.
|
||||
// that face's frame, so its form lies on the face's quarter grid; an edge given with its form
|
||||
// keeps it, and an edge the caller gave a pcurve for keeps the parameter that pcurve is on.
|
||||
let mut frames_of: Vec<Vec<b::Frame>> = vec![Vec::new(); edges.len()];
|
||||
for f in &faces {
|
||||
let Some(frame) = b::form::frame_of(&f.surface) else { continue };
|
||||
@@ -1380,6 +1384,13 @@ pub(crate) fn assemble(parts: Parts, solid: bool) -> Result<Assembled> {
|
||||
let mut labels: Vec<(b::Curve, [f64; 2])> = Vec::with_capacity(edges.len());
|
||||
let mut forms: Vec<Option<(b::Curve, [f64; 2])>> = Vec::with_capacity(edges.len());
|
||||
for ((e, frames), given) in edges.iter().zip(&frames_of).zip(&given_on) {
|
||||
if let Some(form) = &e.nurbs {
|
||||
let on_label =
|
||||
b::curve_interval(&e.curve, Some(form), e.interval).ok_or_else(|| fail("an edge's NURBS form does not evaluate".into()))?;
|
||||
labels.push((e.curve.clone(), on_label));
|
||||
forms.push(Some((form.clone(), e.interval)));
|
||||
continue;
|
||||
}
|
||||
if *given {
|
||||
labels.push((e.curve.clone(), e.interval));
|
||||
forms.push(None);
|
||||
|
||||
@@ -531,6 +531,16 @@ mod imp {
|
||||
/// it when `translate`. SMLib's sweep follows a smooth path; at a corner (the direction
|
||||
/// jumping) the path is swept piece by piece ([`cornered`]).
|
||||
pub(crate) fn sweep(plane: &Plane, pieces: &[Piece], path: &[crate::PathSeg], translate: bool) -> Result<Body> {
|
||||
if translate {
|
||||
// Every segment's direction of travel, at its ends and between them.
|
||||
let bad = || KernelError::Invalid("a path segment has no direction".into());
|
||||
let tangents = path
|
||||
.iter()
|
||||
.flat_map(|s| (0..=CROSSING_SAMPLES).map(move |i| seg_at(s, i as f64 / CROSSING_SAMPLES as f64).map(|(_, t)| t)))
|
||||
.collect::<Option<Vec<Vec3>>>()
|
||||
.ok_or_else(bad)?;
|
||||
crate::sweep_path::crossing_check(plane, &tangents)?;
|
||||
}
|
||||
let runs = smooth_runs(path)?;
|
||||
if runs.len() > 1 {
|
||||
return cornered(plane, pieces, path, &runs, translate);
|
||||
@@ -823,6 +833,8 @@ mod imp {
|
||||
|
||||
/// Fewest and most stations of a sweep that twists, scales or follows rails.
|
||||
const MIN_STATIONS: usize = 16;
|
||||
/// Directions of travel read along each path segment for the parallel sweep's crossing check.
|
||||
const CROSSING_SAMPLES: usize = 32;
|
||||
const MAX_STATIONS: usize = 2048;
|
||||
|
||||
/// The profile `region` on `plane` swept along the smooth `path` the way `ctl` asks: twisted,
|
||||
|
||||
@@ -765,7 +765,12 @@ pub(crate) fn stitch_no_worse(bodies: &[&Body], tol: f64, exempt: &[u32]) -> Res
|
||||
/// ([`crate::offset_backend::thicken`]).
|
||||
pub fn thicken(body: &Body, thickness: f64, symmetric: bool) -> Result<Body> {
|
||||
body.require_brep("thicken")?;
|
||||
imp::thicken(body, thickness, symmetric)
|
||||
// SMLib holds a sheet's faces with both sides and thickens along their surfaces' natural
|
||||
// normals; a sheet turned to its back (every face used against its natural normal) grows the
|
||||
// other way.
|
||||
let sides = face_sides(body.record());
|
||||
let turned = !sides.is_empty() && sides.iter().all(|forward| !forward);
|
||||
imp::thicken(body, if turned { -thickness } else { thickness }, symmetric)
|
||||
}
|
||||
|
||||
/// The faces `picked` of `body` (indices in its face order) offset one by one by SMLib, each onto
|
||||
|
||||
@@ -221,6 +221,21 @@ fn frames_toward(tangents: &[Vec3], d: Vec3) -> Result<Vec<[Vec3; 3]>> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Kept as drawn (parallel), the profile flattens to nothing where the path runs along its
|
||||
/// plane: the path, by its directions of travel `tangents` (the first leaving the profile), has to
|
||||
/// cross the plane at 5 degrees or more all the way.
|
||||
pub(crate) fn crossing_check(plane: &Plane, tangents: &[Vec3]) -> Result<()> {
|
||||
let n = plane.normal().normalized().ok_or_else(|| KernelError::Invalid("sweep frame".into()))?;
|
||||
let t0 = *tangents.first().ok_or_else(|| KernelError::Invalid("sweep path".into()))?;
|
||||
let axis = if n.dot(t0) < 0.0 { n * -1.0 } else { n };
|
||||
if tangents.iter().any(|t| t.dot(axis) < 5f64.to_radians().sin()) {
|
||||
return Err(KernelError::Invalid(
|
||||
"kept parallel, the profile would lie along the sweep path: the path must keep crossing the profile's plane (by 5 deg or more)".into(),
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Stations shaped by sweep options: each maps a world vector at the first station to its image
|
||||
/// at its own (twisted and scaled about the profile's normal through the first station, then
|
||||
/// turned by the orientation's frames), optionally stretched across a corner (mitre). Twist and
|
||||
@@ -246,12 +261,8 @@ pub(crate) fn controlled_stations(
|
||||
// Twist and scale act about the profile's normal, pointing the way the path leaves it.
|
||||
let n = plane.normal().normalized().ok_or_else(|| KernelError::Invalid("sweep frame".into()))?;
|
||||
let axis = if n.dot(t0) < 0.0 { n * -1.0 } else { n };
|
||||
// Kept as drawn, the profile flattens to nothing where the path runs along its plane: the
|
||||
// path has to cross it at 5 degrees or more all the way.
|
||||
if ctl.orientation == SweepOrientation::Parallel && tangents.iter().any(|t| t.dot(axis) < 5f64.to_radians().sin()) {
|
||||
return Err(KernelError::Invalid(
|
||||
"kept parallel, the profile would lie along the sweep path: the path must keep crossing the profile's plane (by 5 deg or more)".into(),
|
||||
));
|
||||
if ctl.orientation == SweepOrientation::Parallel {
|
||||
crossing_check(plane, tangents)?;
|
||||
}
|
||||
let mut run = Vec::with_capacity(pts.len());
|
||||
let mut total = 0.0;
|
||||
@@ -457,8 +468,9 @@ mod tests {
|
||||
let want = std::f64::consts::PI * 4.0 * len;
|
||||
assert!((v - want).abs() < 0.02 * want, "{v} vs {want}");
|
||||
// The path is its lines (no wall is fitted through the points): a wall per profile
|
||||
// segment (the circle's two arcs) along each of the 40 lines, and two caps.
|
||||
assert_eq!(b.faces(0.01).unwrap().len(), 2 * 40 + 2, "walls along each line");
|
||||
// segment (the circle is one closed arc, one edge in SMLib) along each of the 40 lines,
|
||||
// and two caps.
|
||||
assert_eq!(b.faces(0.01).unwrap().len(), 40 + 2, "walls along each line");
|
||||
// An L-shaped path (a sharp corner) with a holed square: mitred ruled walls.
|
||||
let path = [Vec3::ZERO, Vec3::new(0.0, 0.0, 20.0), Vec3::new(20.0, 0.0, 20.0)];
|
||||
let plane = Plane::from_normal(Vec3::ZERO, Vec3::Z).unwrap();
|
||||
|
||||
@@ -784,11 +784,16 @@ fn a_face_bounded_by_two_short_arcs_keeps_an_area_to_mesh() {
|
||||
let sq = [[3000.0, 0.0, 0.0], [5000.0, 0.0, 0.0], [5000.0, 2000.0, 0.0], [3000.0, 2000.0, 0.0]];
|
||||
let plane = Surface::Plane { origin: [0.0; 3], u_axis: [1.0, 0.0, 0.0], v_axis: [0.0, 1.0, 0.0] };
|
||||
let mut edges = vec![
|
||||
PartEdge { curve: circle(-c), interval: [top, PI - top], vertices: [0, 1] },
|
||||
PartEdge { curve: circle(c), interval: [PI + top, TAU - top], vertices: [1, 0] },
|
||||
PartEdge { nurbs: None, curve: circle(-c), interval: [top, PI - top], vertices: [0, 1] },
|
||||
PartEdge { nurbs: None, curve: circle(c), interval: [PI + top, TAU - top], vertices: [1, 0] },
|
||||
];
|
||||
for k in 0..4 {
|
||||
edges.push(PartEdge { curve: line(sq[k], sq[(k + 1) % 4]), interval: [0.0, 1.0], vertices: [2 + k as u32, 2 + ((k + 1) % 4) as u32] });
|
||||
edges.push(PartEdge {
|
||||
nurbs: None,
|
||||
curve: line(sq[k], sq[(k + 1) % 4]),
|
||||
interval: [0.0, 1.0],
|
||||
vertices: [2 + k as u32, 2 + ((k + 1) % 4) as u32],
|
||||
});
|
||||
}
|
||||
let uses = |es: &[u32]| es.iter().map(|&edge| PartUse { edge, forward: true, given: None }).collect::<Vec<_>>();
|
||||
let mut vertices = vec![[half, 0.0, 0.0], [-half, 0.0, 0.0]];
|
||||
|
||||
@@ -61,11 +61,13 @@ fn a_face_touching_its_own_edge_meshes() {
|
||||
let (h, dip) = (0.3175, 2.8e-7);
|
||||
let vertices = vec![[0.0, 0.0, 0.0], [5.0, 0.0, 0.0], [5.0, h, 0.0], [0.0, h, 0.0]];
|
||||
let line = |a: usize, b: usize| PartEdge {
|
||||
nurbs: None,
|
||||
curve: Curve::Line { start: vertices[a], end: vertices[b] },
|
||||
interval: [0.0, 1.0],
|
||||
vertices: [a as u32, b as u32],
|
||||
};
|
||||
let arch = PartEdge {
|
||||
nurbs: None,
|
||||
curve: Curve::Spline { knots: vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0], points: vec![[5.0, h, 0.0], [2.5, -h - 2.0 * dip, 0.0], [0.0, h, 0.0]] },
|
||||
interval: [0.0, 1.0],
|
||||
vertices: [2, 3],
|
||||
|
||||
@@ -531,11 +531,14 @@ fn curves(flat: View, n_edges: usize) -> Res<(Vec<(b::Curve, Option<b::Curve>, [
|
||||
}
|
||||
}
|
||||
CURVE_NURBS => {
|
||||
let c = next_nurbs()?;
|
||||
let c = next_nurbs()?.record();
|
||||
// A NURBS edge stays the NURBS SMLib holds, its trims on its own parameter: SMLib
|
||||
// gives lines, circles and ellipses as their own kinds, and nothing is recognised here.
|
||||
// SMLib's interval may start or end a rounding past its knots (a variable round's
|
||||
// end trimmed by a cylinder, ladder 07-fillets/012: 7e-15 before the first knot).
|
||||
kept += 1;
|
||||
(c.record(), None, r, Some([1.0, 0.0]))
|
||||
let r = onto(r, c.natural());
|
||||
(c, None, r, Some([1.0, 0.0]))
|
||||
}
|
||||
other => return Err(unsupported(format!("SMLib curve kind {other}"))),
|
||||
});
|
||||
@@ -626,8 +629,8 @@ fn mapped(trim: &b::Curve2, same: bool, [scale, offset]: [f64; 2], [t0, t1]: [f6
|
||||
})
|
||||
}
|
||||
|
||||
/// A domain side moved onto the natural range where it overshoots it by rounding (a sphere's
|
||||
/// latitudes, a cone's apex).
|
||||
/// A domain side or an edge's interval moved onto the natural range where it overshoots it by
|
||||
/// rounding (a sphere's latitudes, a cone's apex, a NURBS edge's end knots).
|
||||
fn onto(r: [f64; 2], natural: b::Natural) -> [f64; 2] {
|
||||
match natural {
|
||||
b::Natural::Range(lo, hi) => {
|
||||
|
||||
@@ -227,6 +227,49 @@ mod native_tests {
|
||||
assert!((got - want).abs() < 1e-6 * want, "volume {got} vs {want}");
|
||||
}
|
||||
|
||||
/// The variable round r1 -> r5 along a box's top back edge run on into the R5 round of its
|
||||
/// corner (ladder 07-fillets/012): its end trimmed by the R5 cylinder is a NURBS edge, whose
|
||||
/// interval SMLib gave 7e-15 before the first knot. The record's interval is the NURBS's own
|
||||
/// where it overshoots it by rounding, and the record validates; farther past it stays an error.
|
||||
#[test]
|
||||
fn a_nurbs_edge_interval_a_rounding_past_its_knots_is_moved_onto_them() {
|
||||
let block = Brep::make_box([0.0; 3], [60.0, 40.0, 20.0]).unwrap();
|
||||
let rounded = block.fillet(&[[60.0, 40.0, 10.0]], 0.1, 5.0).unwrap();
|
||||
let r = rounded.fillet_variable([27.5, 40.0, 20.0], 0.1, [0.0, 40.0, 20.0], 1, &[0.0, 0.0, 1.0, 1.0], &[1.0, 5.0]).unwrap();
|
||||
let arrays = r.arrays().unwrap();
|
||||
let kinds = arrays.ints.get(&EDGE_CURVE_TYPE).cloned().unwrap_or_default();
|
||||
let counts = arrays.ints.get(&EDGE_NURBS_VERTEX_COUNT).cloned().unwrap_or_default();
|
||||
let orders = arrays.ints.get(&EDGE_NURBS_ORDER).cloned().unwrap_or_default();
|
||||
let forms = arrays.ints.get(&EDGE_NURBS_FORM).cloned().unwrap_or_default();
|
||||
let knots = arrays.reals.get(&EDGE_NURBS_KNOTS).cloned().unwrap_or_default();
|
||||
// Each NURBS block's first and last knots of its domain, in edge order.
|
||||
let (mut at, mut block_of) = (0usize, Vec::new());
|
||||
for (n, o) in counts.iter().zip(&orders) {
|
||||
let (n, o) = (*n as usize, *o as usize);
|
||||
block_of.push((knots[at + o - 1], knots[at + n]));
|
||||
at += n + o;
|
||||
}
|
||||
let mut nurbs = 0usize;
|
||||
let mut edge = None;
|
||||
for (e, kind) in kinds.iter().enumerate() {
|
||||
let has_block = *kind == CURVE_NURBS || forms.get(e) == Some(&1);
|
||||
if *kind == CURVE_NURBS && edge.is_none() {
|
||||
edge = Some((e, block_of[nurbs]));
|
||||
}
|
||||
nurbs += usize::from(has_block);
|
||||
}
|
||||
let (e, (first, last)) = edge.expect("the round's end on the cylinder is a NURBS edge");
|
||||
let shifted = |by: f64| {
|
||||
let mut a = arrays.clone();
|
||||
a.reals.get_mut(&EDGE_RANGE).unwrap()[2 * e] = first - by;
|
||||
a
|
||||
};
|
||||
let (record, _) = native(&shifted(7e-15)).unwrap();
|
||||
record.validate().unwrap();
|
||||
assert!(record.edges.iter().any(|x| x.interval[0] == first && x.interval[1] <= last), "an interval on the NURBS's first knot");
|
||||
assert!(native(&shifted(1e-3)).map(|(r, _)| r.validate()).map_or(true, |v| v.is_err()), "a real overshoot is not moved");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_arrays_are_errors_never_panics() {
|
||||
let good = Brep::make_box([0.0; 3], [1.0, 2.0, 3.0]).unwrap().arrays().unwrap();
|
||||
|
||||
Reference in New Issue
Block a user