SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 205/509: kernel: union_all, one SMLib union of many bodies checked once, history over every operand (and 3 more)
jyviko3557e3c563b8
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 714f86232a..77e05dd945 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -2699,29 +2699,22 @@ fn sheet_boolean_changes(body: &Body, tools: &[Body], op: Operation) -> Result<bOk(false)}-/// Selected profiles form one machining tool, including disconnected tool material.-/// Balanced unions avoid repeatedly rebuilding a growing aggregate boundary.+/// Selected profiles form one machining tool, including disconnected tool material: their+/// union in one kernel call.fn intersection_tool_union(tools: Vec<Traced>) -> Result<Vec<Traced>> {if tools.len() > 1000 || tools.iter().fold(0usize, |n, t| n.saturating_add(t.body.face_count())) > 16_384 {return Err(DocError::Invalid("intersection tools exceed the bounded geometry budget".into()));}- let mut groups = tools;- while groups.len() > 1 {- let mut next = Vec::new();- let mut iter = groups.into_iter();- while let Some(a) = iter.next() {- match iter.next() {- Some(b) => {- let u = kernel::boolean(&a.body, &b.body, BoolOp::Union)?- .ok_or_else(|| DocError::Invalid("intersection tool union is empty".into()))?;- next.push(Traced::step(u, &[&a, &b]));- }- None => next.push(a),- }- }- groups = next;+ if tools.len() < 2 {+ return Ok(tools);}- Ok(groups)+ Ok(vec![union_all(&tools.iter().collect::<Vec<_>>())?])+}++/// The union of `operands` (traced bodies) in one kernel call, keeping their lineage.+fn union_all(operands: &[&Traced]) -> Result<Traced> {+ let bodies: Vec<&Body> = operands.iter().map(|t| &t.body).collect();+ Ok(Traced::step(kernel::union_all(&bodies)?, operands))}/// After a cut handled some sheet bodies as flat machining, apply it to the other targets.@@ -2923,26 +2916,14 @@ fn apply_traced_with(Ok(Traced::step(u, &[a, b]))};// One target takes every tool, whichever it meets: the result is the union of all of- // them, made in a balanced tree of unions so that each body is in about log2(n) of- // them, instead of the target growing by one tool at a time and taking part, ever- // larger, in every one (n tools cost n²).+ // them in one kernel call, checked once.if let [keep] = live.as_slice()&& tools.len() > 1{let Some(base) = state.body(keep).map(ModelBody::traced) else { return Ok(()) };- let mut level: Vec<Traced> = std::iter::once(base).chain(tools).collect();- while level.len() > 1 {- let mut next = Vec::with_capacity(level.len().div_ceil(2));- let mut it = level.into_iter();- while let Some(a) = it.next() {- next.push(match it.next() {- Some(b) => union(&a, &b)?,- None => a,- });- }- level = next;- }- if let (Some(acc), Some(mb)) = (level.pop(), state.bodies.iter_mut().find(|b| b.name == *keep)) {+ let operands: Vec<&Traced> = std::iter::once(&base).chain(&tools).collect();+ let acc = union_all(&operands)?;+ if let Some(mb) = state.bodies.iter_mut().find(|b| b.name == *keep) {*mb = ModelBody::traced_new(mb.name.clone(), acc, mb.feature);}return Ok(());diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rsindex 77436d8dde..75bf796638 100644--- a/crates/kernel/src/lib.rs+++ b/crates/kernel/src/lib.rs@@ -188,7 +188,7 @@ pub use meshbody::{MAX_TRIANGLES, mesh_body};pub use native::{body_from_smlib, smlib_body};pub use native::{brep_record, decode_native_body, encode_native_body, native_preview_mesh};pub use offset::with_same_surface;-pub use ops::{BoolOp, boolean, half_space, join_apart, place_matrix, split_by_plane, transform, transform_matrix, union_apart};+pub use ops::{BoolOp, boolean, half_space, join_apart, place_matrix, split_by_plane, transform, transform_matrix, union_all, union_apart};pub use point_path::{PathPiece, PointPath, SpaceBezier, curve_path, edge_path, face_section_along, iso_curves, project_onto_face, sketch_record_curve,sweep_point_path_with,diff --git a/crates/kernel/src/ops.rs b/crates/kernel/src/ops.rsindex 676a5de70c..1f1ce9832a 100644--- a/crates/kernel/src/ops.rs+++ b/crates/kernel/src/ops.rs@@ -29,16 +29,31 @@ pub fn boolean(a: &Body, b: &Body, op: BoolOp) -> Result<Option<Body>> {})}+/// The union of `bodies` (at least one) in one SMLib call, each body taking part in about+/// log2(n) of its unions, the result checked once. A result SMLib's check refuses is an error.+///+/// The result carries its exact history over `bodies` in order, as [`boolean`]'s does, and+/// what the operands' faces stood for (their regularization protection and the planar roles on+/// supports it kept).+pub fn union_all(bodies: &[&Body]) -> Result<Body> {+ crate::profile::timed(crate::profile::Kind::Boolean, || {+ if bodies.is_empty() {+ return Err(KernelError::Invalid("a union of no bodies".into()));+ }+ guard("SMLib union", || crate::smlib_boolean::smlib_union_all(bodies))?.with_preserved_union_planar_sources(bodies)+ })+}+/// A boolean's result with what its operands' faces stood for carried over: regularization/// protection and the planar construction and shell roles on supports it kept.fn with_operand_roles(a: &Body, b: &Body, op: BoolOp, r: Result<Option<Body>>) -> Result<Option<Body>> {let r = r.map(|result| result.map(|body| body.inherit_regularization_protection(a).inherit_regularization_protection(b)));match op {BoolOp::Cut => r.and_then(|result| result.map(|body| body.with_preserved_boolean_planar_sources(a, b, true)).transpose()),- BoolOp::Union => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(a, b)).transpose()),+ BoolOp::Union => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(&[a, b])).transpose()),// Every face of an intersection lies on one operand's face, as a union's does: the same// roles carry over (#565).- BoolOp::Intersect => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(a, b)).transpose()),+ BoolOp::Intersect => r.and_then(|result| result.map(|body| body.with_preserved_union_planar_sources(&[a, b])).transpose()),}}diff --git a/crates/kernel/src/planar_sources.rs b/crates/kernel/src/planar_sources.rsindex 61ad9722d7..af081a1f58 100644--- a/crates/kernel/src/planar_sources.rs+++ b/crates/kernel/src/planar_sources.rs@@ -151,15 +151,15 @@ impl Body {self_.map_planar_sources(&[input], None, Some(tool), &[], constructed)}- /// Retain exact construction and shell roles through a Union from both operands, only on- /// unchanged supports. Coplanar supports of the two operands carry distinct identities, so- /// a face merged from both stays without a role.- pub(crate) fn with_preserved_union_planar_sources(self, a: &Body, b: &Body) -> Result<Self> {- let self_ = self.inherit_regularization_protection(a).inherit_regularization_protection(b);- if ![a, b].iter().any(|input| input.face_sources().is_some_and(|sources| sources.iter().flatten().any(|s| boolean_source(s, true)))) {+ /// Retain exact construction and shell roles through a Union from every operand, only on+ /// unchanged supports. Coplanar supports of different operands carry distinct identities, so+ /// a face merged from several stays without a role.+ pub(crate) fn with_preserved_union_planar_sources(self, operands: &[&Body]) -> Result<Self> {+ let self_ = operands.iter().fold(self, |body, operand| body.inherit_regularization_protection(operand));+ if !operands.iter().any(|input| input.face_sources().is_some_and(|sources| sources.iter().flatten().any(|s| boolean_source(s, true)))) {return Ok(self_);}- self_.map_planar_sources(&[a, b], None, None, &[], true)+ self_.map_planar_sources(operands, None, None, &[], true)}fn map_planar_sources(mut self, inputs: &[&Body], shell: Option<f64>, blocker: Option<&Body>, open: &[Vec3], constructed: bool) -> Result<Self> {@@ -172,7 +172,8 @@ impl Body {if inputs.iter().all(|input| input.face_sources().is_none()) {return Ok(self);}- if inputs.len() > 2+ // Each body at most 16 384 faces, and the inputs together at most two such bodies' worth.+ if inputs.iter().fold(0usize, |n, input| n.saturating_add(input.face_count())) > 2 * 16_384|| inputs.iter().any(|input| input.face_count() > 16_384)|| self.face_count() > 16_384|| blocker.is_some_and(|b| b.face_count() > 16_384)diff --git a/crates/kernel/src/smlib_boolean.rs b/crates/kernel/src/smlib_boolean.rsindex 719cacca57..87f41d0d31 100644--- a/crates/kernel/src/smlib_boolean.rs+++ b/crates/kernel/src/smlib_boolean.rs@@ -4,7 +4,7 @@//! ([`crate::history::History`]'s contract). A result SMLib's own check or the record's geometry//! check refuses is an error, never a body.-pub(crate) use smlib::boolean as smlib_boolean;+pub(crate) use smlib::{boolean as smlib_boolean, union_all as smlib_union_all};mod smlib {use solidcraft_smlib::{BooleanOp, CheckLevel};@@ -34,6 +34,54 @@ mod smlib {BoolOp::Intersect => BooleanOp::Intersect,};let Some(r) = ta.boolean(&tb, kind).map_err(|e| failed("operation", e))? else { return Ok(None) };+ checked(&r, &[&sa, &sb])?;+ let (body, or) = body_from_smlib_ordered(&r)?;+ let history = match (oa, ob, or) {+ (Some(oa), Some(ob), Some(or)) => r.history().map_err(|e| failed("history", e))?.history(&[oa, ob], &or).map(Some).unwrap_or_else(|e| {+ log::debug!(target: "smlib", "boolean history: {e}");+ None+ }),+ _ => None,+ };+ Ok(Some(with_history(body, history, a, b)))+ }++ /// The union of `bodies` in one SMLib call, each tagged as its own operand, checked once:+ /// the result's history is over `bodies` in order. At least one body.+ pub(crate) fn union_all(bodies: &[&Body]) -> Result<Body> {+ if bodies.len() > solidcraft_smlib::MAX_UNION_BREPS {+ return Err(KernelError::Invalid(format!("a union takes at most {} bodies", solidcraft_smlib::MAX_UNION_BREPS)));+ }+ let mut operands = Vec::with_capacity(bodies.len());+ let mut tagged = Vec::with_capacity(bodies.len());+ let mut orders = Some(Vec::with_capacity(bodies.len()));+ for (i, body) in bodies.iter().enumerate() {+ body.require_brep("a union")?;+ let (s, order) = smlib_body_ordered(body)?;+ tagged.push(s.tagged(i).map_err(|e| failed("tag", e))?);+ operands.push(s);+ orders = orders.zip(order).map(|(mut v, o)| {+ v.push(o);+ v+ });+ }+ let refs: Vec<&solidcraft_smlib::Brep> = tagged.iter().collect();+ let r = solidcraft_smlib::Brep::union_all(&refs).map_err(|e| failed("operation", e))?;+ let operand_refs: Vec<&solidcraft_smlib::Brep> = operands.iter().collect();+ checked(&r, &operand_refs)?;+ let (body, or) = body_from_smlib_ordered(&r)?;+ let history = match (orders, or) {+ (Some(orders), Some(or)) => r.history().map_err(|e| failed("history", e))?.history(&orders, &or).map(Some).unwrap_or_else(|e| {+ log::debug!(target: "smlib", "union history: {e}");+ None+ }),+ _ => None,+ };+ Ok(body.with_checked_history(history, &record::counts(bodies)))+ }++ /// An error unless SMLib's check accepts `r`, the result of combining `operands`.+ fn checked(r: &solidcraft_smlib::Brep, operands: &[&solidcraft_smlib::Brep]) -> Result<()> {// Solids touching each other along an edge or at a vertex come back as one non-manifold// body, which the export splits into separate solids: SMLib's check is of those, imported// as given (its check of the touching arrangement itself refuses the radial order of@@ -46,29 +94,26 @@ mod smlib {let split = solidcraft_smlib::Brep::from_record(&record, true).map_err(|e| failed("the separate solids", e))?;split.check(CheckLevel::All).map_err(|e| failed("check", e))?};- if !check.is_valid() {- // Whether an operand failed it already says whose the fault is.- let operands: Vec<&str> = [("the first operand", &sa), ("the second operand", &sb)]- .into_iter()- .filter(|(_, s)| s.check(CheckLevel::All).is_ok_and(|c| !c.is_valid()))- .map(|(name, _)| name)- .collect();- let what = if operands.is_empty() {- "SMLib's check refuses the result".to_string()- } else {- format!("SMLib's check refuses the result ({} already fails it)", operands.join(" and "))- };- return Err(failed(&what, check));+ if check.is_valid() {+ return Ok(());}- let (body, or) = body_from_smlib_ordered(&r)?;- let history = match (oa, ob, or) {- (Some(oa), Some(ob), Some(or)) => r.history().map_err(|e| failed("history", e))?.history(&[oa, ob], &or).map(Some).unwrap_or_else(|e| {- log::debug!(target: "smlib", "boolean history: {e}");- None- }),- _ => None,+ // Whether an operand failed it already says whose the fault is.+ let failing: Vec<String> = operands+ .iter()+ .enumerate()+ .filter(|(_, s)| s.check(CheckLevel::All).is_ok_and(|c| !c.is_valid()))+ .map(|(i, _)| match (operands.len(), i) {+ (2, 0) => "the first operand".to_string(),+ (2, _) => "the second operand".to_string(),+ _ => format!("operand {i}"),+ })+ .collect();+ let what = if failing.is_empty() {+ "SMLib's check refuses the result".to_string()+ } else {+ format!("SMLib's check refuses the result ({} already fails it)", failing.join(" and "))};- Ok(Some(with_history(body, history, a, b)))+ Err(failed(&what, check))}/// `body` with `history` where it describes `body` made from `a` and `b`.diff --git a/crates/smlib/src/ffi/ops.rs b/crates/smlib/src/ffi/ops.rsindex 248086e4b5..47c055c6ba 100644--- a/crates/smlib/src/ffi/ops.rs+++ b/crates/smlib/src/ffi/ops.rs@@ -1,4 +1,4 @@-//! The operations block of `capi/include/smlib.h` (`smlib_boolean`, `smlib_boolean2d`, `smlib_fillet`,+//! The operations block of `capi/include/smlib.h` (`smlib_boolean`, `smlib_boolean_union_all`, `smlib_boolean2d`, `smlib_fillet`,//! `smlib_chamfer`, `smlib_blend`, `smlib_fillet_variable`, `smlib_chamfer_sides`, `smlib_shell`, `smlib_offset_faces`,//! `smlib_thicken`, `smlib_draft`, `smlib_merge_faces`, `smlib_brep_solid_count`, `smlib_imprint`; the fork's `capi/src/smlib_ops.cpp`), declared by//! hand. Part of the FFI boundary, like its parent: called only through@@ -48,6 +48,7 @@ type PickFn = unsafe extern "C" fn(*const RawBrep, *const f64, i64, f64, f64, *m#[cfg(feature = "native")]unsafe extern "C" {fn smlib_boolean(a: *const RawBrep, b: *const RawBrep, op: i32, out: *mut *mut RawBrep) -> i32;+ fn smlib_boolean_union_all(breps: *const *const RawBrep, n: i64, out: *mut *mut RawBrep) -> i32;fn smlib_boolean2d(a: *const RawBrep, b: *const RawBrep, op: i32, out: *mut *mut RawBrep) -> i32;fn smlib_brep_solid_count(brep: *const RawBrep, out: *mut i64) -> i32;fn smlib_imprint(body: *const RawBrep, tool: *const RawBrep, out: *mut *mut RawBrep) -> i32;@@ -149,6 +150,13 @@ pub fn boolean(a: &Handle, b: &Handle, op: i32) -> Result<Handle, i32> {new_brep(|out| unsafe { smlib_boolean(a.raw(), b.raw(), op, out) })}+#[cfg(feature = "native")]+pub fn boolean_union_all(breps: &[&Handle]) -> Result<Handle, i32> {+ let raw: Vec<*const RawBrep> = breps.iter().map(|h| h.raw()).collect();+ let n = i64::try_from(raw.len()).map_err(|_| ERR_ARG)?;+ new_brep(|out| unsafe { smlib_boolean_union_all(raw.as_ptr(), n, out) })+}+#[cfg(feature = "native")]pub fn boolean2d(a: &Handle, b: &Handle, op: i32) -> Result<Handle, i32> {new_brep(|out| unsafe { smlib_boolean2d(a.raw(), b.raw(), op, out) })@@ -315,6 +323,11 @@ pub fn boolean(_: &Handle, _: &Handle, _: i32) -> Result<Handle, i32> {Err(NOT_BUILT)}+#[cfg(not(feature = "native"))]+pub fn boolean_union_all(_: &[&Handle]) -> Result<Handle, i32> {+ Err(NOT_BUILT)+}+#[cfg(not(feature = "native"))]pub fn boolean2d(_: &Handle, _: &Handle, _: i32) -> Result<Handle, i32> {Err(NOT_BUILT)diff --git a/crates/smlib/src/lib.rs b/crates/smlib/src/lib.rsindex e832683ae6..8b683d17f4 100644--- a/crates/smlib/src/lib.rs+++ b/crates/smlib/src/lib.rs@@ -31,7 +31,7 @@ pub mod trim;pub use check::{CheckLevel, CheckReport};pub use measure::{MEASURE_ACCURACY, MassProperties};-pub use ops::{Blend, BooleanOp, ChamferSecond, MAX_POINTS};+pub use ops::{Blend, BooleanOp, ChamferSecond, MAX_POINTS, MAX_UNION_BREPS};/// Why an SMLib call failed.#[derive(Clone, Debug, PartialEq)]diff --git a/crates/smlib/src/ops.rs b/crates/smlib/src/ops.rsindex 866d65b891..0e18c4d719 100644--- a/crates/smlib/src/ops.rs+++ b/crates/smlib/src/ops.rs@@ -41,6 +41,9 @@ pub enum ChamferSecond {Angle(f64),}+/// Most bodies [`Brep::union_all`] takes (the C API's limit).+pub const MAX_UNION_BREPS: usize = 100_000;+/// Most points one selection may hold (the C API's limit).pub const MAX_POINTS: usize = 4096;@@ -71,6 +74,19 @@ impl Brep {}}+ /// The union of `breps` in one call: they are unioned pairwise, level by level, so none takes+ /// part in more than about log2(n) unions. The result is as [`Brep::boolean`]'s; operands+ /// tagged each with its own number ([`Brep::tagged`]) give a result whose [`Brep::history`]+ /// names them. At least one body and at most [`MAX_UNION_BREPS`].+ pub fn union_all(breps: &[&Brep]) -> Result<Brep> {+ init()?;+ if breps.is_empty() || breps.len() > MAX_UNION_BREPS {+ return Err(error(ffi::ERR_ARG));+ }+ let handles: Vec<&ffi::Handle> = breps.iter().map(|b| &b.0).collect();+ ffi::ops::boolean_union_all(&handles).map(Brep).map_err(error)+ }+/// `self` and `other`, sheets of planar faces on one plane ([`Brep::planar_faces`]), combined/// as regions of that plane by `op`: `None` when the result is empty. The result's edges are/// the inputs' own curves, split where they cross.diff --git a/crates/step/src/topology.rs b/crates/step/src/topology.rsindex 3a2c599e82..a0bd2a8b04 100644--- a/crates/step/src/topology.rs+++ b/crates/step/src/topology.rs@@ -580,7 +580,7 @@ impl<'b, 'a> Builder<'b, 'a> {return Err(format!("face #{id}: {}", unsupported("a face without an edge loop")));}let extent = self.extent(&loops)?;- let (surface, reversed) = swept::map_surface(&step_surface, &extent).map_err(|m| format!("face #{id}: {m}"))?;+ let (surface, reversed) = swept::map_surface(&step_surface, &extent, self.tol).map_err(|m| format!("face #{id}: {m}"))?;// Loops relative to the record's natural normal: the face's normal is STEP's surface// normal when same_sense, and the record's is STEP's unless `reversed`.let sense = same_sense != reversed;diff --git a/crates/step/src/topology/swept.rs b/crates/step/src/topology/swept.rsindex aee6ee9e81..b043aff467 100644--- a/crates/step/src/topology/swept.rs+++ b/crates/step/src/topology/swept.rs@@ -482,10 +482,12 @@ fn offset(s: BSurface, d: f64) -> R<BSurface> {/// A face's surface as a schema surface, and whether the record's natural normal is opposite/// STEP's surface normal (an extruded circle or revolved circle read as a cylinder or torus,-/// whose natural normals point away from their axes); `ext` bounds swept surfaces' profiles.-pub(super) fn map_surface(s: &Surface, ext: &Extent) -> R<(BSurface, bool)> {+/// whose natural normals point away from their axes); `ext` bounds swept surfaces' profiles,+/// and a cone that stays within `tol` (the file's distance uncertainty) of its limit plane+/// over `ext` is read as that plane.+pub(super) fn map_surface(s: &Surface, ext: &Extent, tol: f64) -> R<(BSurface, bool)> {let mut reversed = false;- let s = map_surface_in(s, ext, 0, &mut reversed)?;+ let s = map_surface_in(s, ext, tol, 0, &mut reversed)?;Ok((s, reversed))}@@ -538,7 +540,7 @@ fn canonical(s: &Surface, reversed: &mut bool) -> Option<BSurface> {}}-fn map_surface_in(s: &Surface, ext: &Extent, depth: usize, reversed: &mut bool) -> R<BSurface> {+fn map_surface_in(s: &Surface, ext: &Extent, tol: f64, depth: usize, reversed: &mut bool) -> R<BSurface> {if depth > MAX_NESTING {return Err("surfaces nested too deeply".into());}@@ -549,6 +551,9 @@ fn map_surface_in(s: &Surface, ext: &Extent, depth: usize, reversed: &mut bool)Surface::Plane { position } => BSurface::Plane { origin: position.origin, u_axis: position.ref_direction, v_axis: position.y() },Surface::Cylinder { position, radius } => BSurface::Cylinder { frame: frame(position), radius: *radius },Surface::Cone { position, radius, semi_angle } => {+ if let Some(plane) = flat_cone(position, *radius, *semi_angle, ext, tol, reversed) {+ return Ok(plane);+ }if !(*radius >= 0.0) || !(semi_angle.abs() > 1e-12 && semi_angle.abs() < FRAC_PI_2) {return Err(unsupported(format!("a cone of radius {radius} and semi-angle {semi_angle}")));}@@ -563,17 +568,48 @@ fn map_surface_in(s: &Surface, ext: &Extent, depth: usize, reversed: &mut bool)}Surface::DegenerateTorus { .. } => return Err(unsupported("DEGENERATE_TOROIDAL_SURFACE")),Surface::BSpline(b) => super::map_bspline_surface(b)?,- Surface::RectangularTrimmed { basis, .. } => map_surface_in(basis, ext, depth + 1, reversed)?,+ Surface::RectangularTrimmed { basis, .. } => map_surface_in(basis, ext, tol, depth + 1, reversed)?,Surface::Revolution { profile, axis } => revolution(profile, axis, ext)?,Surface::Extrusion { profile, direction, magnitude } => extrusion(profile, *direction, *magnitude, ext)?,Surface::Offset { basis, distance, .. } => {// Along STEP's normal: the record's, or its opposite.- let b = map_surface_in(basis, ext, depth + 1, reversed)?;+ let b = map_surface_in(basis, ext, tol, depth + 1, reversed)?;offset(b, if *reversed { -*distance } else { *distance })?}})}+/// A cone written for a plane (a semi-angle a whisker short of 90°, as exporters write one) as+/// that plane: the plane through the placement's origin across its axis, the cone's limit as+/// its angle opens to 90°. The cone's height above it is `(rho - radius) cot a` at parameter+/// radius `rho`, monotone in `rho` away from the apex: over the face it stays within the+/// heights of the boundary points and, should the face hold the axis, the apex's+/// (`radius cot a`). `None` unless that deviation is within `tol`. STEP's normal there is+/// `-rho tan a` along the axis, so the record's (the axis) is opposite STEP's where+/// `rho tan a > 0`.+fn flat_cone(position: &Placement, radius: f64, semi_angle: f64, ext: &Extent, tol: f64, reversed: &mut bool) -> Option<BSurface> {+ let (o, k) = (v3(position.origin), v3(position.axis).normalized()?);+ let cot = semi_angle.cos() / semi_angle.sin();+ let mut deviation = (radius * cot).abs();+ let mut widest: Option<(f64, f64)> = None;+ for p in &ext.points {+ let d = *p - o;+ let h = d.dot(k);+ deviation = deviation.max(h.abs());+ let r = (d - k * h).len();+ if widest.is_none_or(|(w, _)| r > w) {+ widest = Some((r, h));+ }+ }+ let (_, h) = widest?;+ if !(deviation <= tol) {+ return None;+ }+ // The parameter radius at the widest boundary point (it keeps one sign off the apex).+ *reversed ^= (radius + h * semi_angle.tan()) * semi_angle.tan() > 0.0;+ Some(BSurface::Plane { origin: position.origin, u_axis: position.ref_direction, v_axis: position.y() })+}+/// The STEP parameters of `ps` and `pe` on a hyperbola or parabola.pub(super) fn open_conic_params(c: &Curve, ps: P3, pe: P3) -> R<(f64, f64)> {match (planar_param(c, v3(ps)), planar_param(c, v3(pe))) {diff --git a/crates/step/src/topology_tests.rs b/crates/step/src/topology_tests.rsindex f4e166c2d4..e5ba31defb 100644--- a/crates/step/src/topology_tests.rs+++ b/crates/step/src/topology_tests.rs@@ -906,7 +906,7 @@ fn same_surface(data: &str, us: (f64, f64), vs: (f64, f64)) -> BSurface {.flat_map(|i| (0..=n).map(move |j| (us.0 + (us.1 - us.0) * i as f64 / n as f64, vs.0 + (vs.1 - vs.0) * j as f64 / n as f64))).collect();let ext = swept::Extent { points: grid.iter().map(|&(u, v)| v3(s.point(u, v).unwrap())).collect(), seam: Vec::new() };- let (record, reversed) = swept::map_surface(&s, &ext).unwrap();+ let (record, reversed) = swept::map_surface(&s, &ext, DEFAULT_TOLERANCE).unwrap();record.natural();let eval = SurfaceEval::new(&record).unwrap();for &(u, v) in &grid {@@ -1003,7 +1003,7 @@ fn swept_and_offset_surfaces_are_the_files_own() {"#1=CARTESIAN_POINT('',(0.,0.,0.));#2=DIRECTION('',(0.,0.,1.));#3=DIRECTION('',(1.,0.,0.));#4=AXIS2_PLACEMENT_3D('',#1,#2,#3);{data}\n"));let s = crate::read::Reader::new(&exch, crate::read::Units::default()).surface(10).unwrap();- let e = swept::map_surface(&s, &ext).unwrap_err();+ let e = swept::map_surface(&s, &ext, DEFAULT_TOLERANCE).unwrap_err();assert!(e.contains(why), "{data}: {e}");}}