SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 154/509: kernel: planar region booleans are SMLib's exact 2D boolean
jyviko73e763679064
diff --git a/crates/kernel/src/prism.rs b/crates/kernel/src/prism.rsindex 95300ae197..9297f3411d 100644--- a/crates/kernel/src/prism.rs+++ b/crates/kernel/src/prism.rs@@ -1,267 +1,240 @@-//! Booleans of planar regions in 2D (an arrangement of their lines, arcs and free-form-//! curves), the extrusion of planar material from them, and the test of whether a record-//! surface is a wall swept along a direction.--use std::borrow::Cow;+//! Booleans of planar regions (lines, circular arcs and free-form curves) and the extrusion of+//! planar material from them, both on SMLib's 2D boolean: each operand a sheet of planar faces+//! built from its loops' own curves, combined as regions of the plane, its faces read back. The+//! result's boundaries are the operands' curves, cut at their crossings and never refitted.+//! Also the test of whether a record surface is a wall swept along a direction.use solidcraft_geom::brep::Surface;-use solidcraft_geom::{Aabb2, Loop2, Plane, Region2, Seg2, Vec2, Vec3};+use solidcraft_geom::{Plane, Region2, Seg2, Vec2, Vec3};use crate::body::Body;use crate::{BoolOp, KernelError, Result};const MAX_PLANAR_SEGMENTS: usize = 8192;-const MAX_PLANAR_EVENTS: usize = 131_072;-const MAX_PLANAR_PAIRS: usize = 16_000_000;-/// Free-form boundary segments (conics, Béziers) take part in planar booleans as lines and-/// arcs within this distance (mm); loops that come out whole get their exact segments back.+/// How far a free-form boundary may be replaced by lines and arcs where a caller needs lines and+/// arcs only (sheet metal's flat patterns, mm). The booleans here keep free-form curves exact.pub const PLANAR_FIT_TOL: f64 = 1e-3;-/// Boolean of planar regions bounded by straight lines, circular arcs and free-form segments.-/// Lines and arcs stay analytic. Free-form loops are arranged as tangent arcs within-/// [`PLANAR_FIT_TOL`]: a loop the operation leaves whole comes back exact, one it cuts keeps-/// the arcs. Disjoint results and retained islands are returned as separate regions.+/// Boolean of planar regions bounded by straight lines, circular arcs and free-form segments,+/// exact: every boundary of the result is a piece of a boundary of `a` or `b`, cut where it+/// crosses the other (SMLib's 2D boolean). Disjoint results and retained islands are returned as+/// separate regions. `tolerance` (mm, 1e-9 to 1) is how far apart a loop's segments may end and+/// still close it.pub fn planar_regions_boolean(a: &[Region2], b: &[Region2], op: BoolOp, tolerance: f64) -> Result<Vec<Region2>> {crate::guard("planar region boolean", || {if !tolerance.is_finite() || !(1e-9..=1.0).contains(&tolerance) {return Err(KernelError::Invalid("planar boolean tolerance must be finite and between 1e-9 and 1 mm".into()));}- let mut exact: Vec<(Loop2, Loop2)> = Vec::new();- let mut pieces = 0usize;- let (a, b) = (fit_free_form(a, &mut exact, &mut pieces)?, fit_free_form(b, &mut exact, &mut pieces)?);- let (a, b): (&[Region2], &[Region2]) = (&a, &b);- let loops = || a.iter().chain(b).flat_map(|r| std::iter::once(&r.outer).chain(&r.holes));- let mut edges = 0usize;- let mut samples = 0usize;- for lp in loops() {- edges = edges.saturating_add(lp.segs.len());- if edges > MAX_PLANAR_SEGMENTS || lp.segs.is_empty() || !lp.is_closed(tolerance * 10.0) {- return Err(KernelError::Invalid("planar boolean needs closed loops within its geometry budget".into()));- }- for s in &lp.segs {- let finite = |p: Vec2| p.x.is_finite() && p.y.is_finite() && p.x.abs() < 1e9 && p.y.abs() < 1e9;- let valid = match *s {- Seg2::Line { a, b } => finite(a) && finite(b) && a.dist(b) > 1e-12,- Seg2::Arc { center, radius, start, sweep } => {- finite(center)- && radius.is_finite()- && radius > 0.0- && radius < 1e9- && start.is_finite()- && sweep.is_finite()- && sweep.abs() > 1e-12- && sweep.abs() <= std::f64::consts::TAU + 1e-9- }- _ => false,- };- if !valid {- return Err(KernelError::Invalid("planar boolean supports finite nondegenerate lines and circular arcs".into()));- }- samples = samples.saturating_add(s.polyline(1e-3).len());- if samples > 65_536 {- return Err(KernelError::Invalid("planar boolean sampled geometry exceeds its budget".into()));- }- }- }- let out = boolean2d(a, b, op, tolerance)- .ok_or_else(|| KernelError::Failed("planar region arrangement failed or exceeded its bounded processing budget".into()))?;- Ok(restore_exact_loops(out, &exact, tolerance))+ check_regions(a.iter().chain(b), tolerance)?;+ match (a.is_empty(), b.is_empty(), op) {+ (true, _, BoolOp::Union) => return Ok(b.to_vec()),+ (true, _, _) | (false, true, BoolOp::Intersect) => return Ok(Vec::new()),+ (false, true, _) => return Ok(a.to_vec()),+ _ => {}+ }+ let r = sheets::combine(&sheets::sheet(a)?, &sheets::sheet(b)?, op)?;+ Ok(match r {+ Some(sheet) => sheets::regions(&sheet, tolerance)?.regions,+ None => Vec::new(),+ })})}-/// Regions with their free-form loops fitted by lines and arcs; `exact` records each fitted-/// loop with the loop it stands for, `pieces` counts the fitted segments. Regions of lines and-/// arcs alone are passed on as they are.-fn fit_free_form<'a>(regions: &'a [Region2], exact: &mut Vec<(Loop2, Loop2)>, pieces: &mut usize) -> Result<Cow<'a, [Region2]>> {- if regions.iter().all(Region2::is_line_arc) {- return Ok(Cow::Borrowed(regions));- }- let mut fit = |lp: &Loop2| -> Result<Loop2> {- if lp.is_line_arc() {- return Ok(lp.clone());- }- let fitted = lp.fit_arcs(PLANAR_FIT_TOL).filter(|f| {- *pieces = pieces.saturating_add(f.segs.len());- *pieces <= MAX_PLANAR_SEGMENTS- });- let fitted = fitted.ok_or_else(|| {- KernelError::Invalid("planar boolean: a free-form boundary is not finite or takes more arcs than the geometry budget".into())- })?;- exact.push((fitted.clone(), lp.clone()));- Ok(fitted)- };- let fitted: Result<Vec<Region2>> =- regions.iter().map(|r| Ok(Region2 { outer: fit(&r.outer)?, holes: r.holes.iter().map(&mut fit).collect::<Result<_>>()? })).collect();- fitted.map(Cow::Owned)-}--/// Output loops that are a fitted free-form loop, whole (from any start, either way round), get-/// the exact loop back, running the same way.-fn restore_exact_loops(regions: Vec<Region2>, exact: &[(Loop2, Loop2)], tol: f64) -> Vec<Region2> {- if exact.is_empty() {- return regions;- }- let near = |p: Vec2, q: Vec2| p.dist(q) <= tol * 10.0;- let same_run = |l: &Loop2, f: &Loop2| -> bool {- let n = f.segs.len();- let Some(first) = l.segs.first() else { return false };- (0..n).any(|k| {- f.segs.get(k).is_some_and(|s| near(s.start(), first.start()))- && l.segs.iter().enumerate().all(|(i, s)| {- f.segs.get((k + i) % n).is_some_and(|g| near(g.start(), s.start()) && near(g.end(), s.end()) && near(g.mid(), s.mid()))- })- })- };- let restore = |l: Loop2| -> Loop2 {- for (fitted, original) in exact {- if fitted.segs.len() != l.segs.len() {- continue;- }- if same_run(&l, fitted) {- return original.clone();- }- if same_run(&l, &fitted.reversed()) {- return original.reversed();+/// Each loop closed within ten times `tol` and within the segment budget, each segment finite+/// and of some length (a line's ends apart, an arc of a positive radius turning at most once).+fn check_regions<'a>(regions: impl Iterator<Item = &'a Region2>, tol: f64) -> Result<()> {+ let mut edges = 0usize;+ for lp in regions.flat_map(|r| std::iter::once(&r.outer).chain(&r.holes)) {+ edges = edges.saturating_add(lp.segs.len());+ if edges > MAX_PLANAR_SEGMENTS || lp.segs.is_empty() || !lp.is_closed(tol * 10.0) {+ return Err(KernelError::Invalid("planar boolean needs closed loops within its geometry budget".into()));+ }+ let finite = |p: Vec2| p.x.is_finite() && p.y.is_finite() && p.x.abs() < 1e9 && p.y.abs() < 1e9;+ for s in &lp.segs {+ let valid = match *s {+ Seg2::Line { a, b } => finite(a) && finite(b) && a.dist(b) > 1e-12,+ Seg2::Arc { center, radius, start, sweep } => {+ finite(center)+ && radius.is_finite()+ && radius > 0.0+ && radius < 1e9+ && start.is_finite()+ && sweep.is_finite()+ && sweep.abs() > 1e-12+ && sweep.abs() <= std::f64::consts::TAU + 1e-9+ }+ Seg2::Cubic { p0, p1, p2, p3 } => [p0, p1, p2, p3].into_iter().all(finite) && p0.dist(p3) > 1e-12,+ Seg2::Conic { a, apex, b, w } => [a, apex, b].into_iter().all(finite) && w.is_finite() && w > 1e-9 && a.dist(b) > 1e-12,+ Seg2::Bezier { n, ref p } => {+ p.get(..=usize::from(n)).is_some_and(|p| p.iter().copied().all(finite)) && s.start().dist(s.end()) > 1e-12+ }+ };+ if !valid {+ let what = if s.is_line_or_arc() { "lines and circular arcs" } else { "free-form segments" };+ return Err(KernelError::Invalid(format!("planar boolean supports finite nondegenerate {what}")));}}- l- };- regions.into_iter().map(|r| Region2 { outer: restore(r.outer), holes: r.holes.into_iter().map(&restore).collect() }).collect()+ }+ Ok(())}/// Extrude normalized planar material as one logical compound, retaining every disjoint-/// region and its holes. Planar arrangement certifies separation before shells are joined.+/// region and its holes. The regions are united in the plane first (each its own operand, so+/// overlapping ones merge), and pieces of the union that touch each other are refused: apart,+/// each is extruded on its own and the solids joined as one body.pub fn extrude_planar_regions(plane: &Plane, regions: &[Region2], start: f64, end: f64) -> Result<Body> {crate::guard("planar material extrusion", || {- // Validate aggregate inputs first; an arrangement compares opposite operands,- // so regions in the same operand must be normalized through balanced unions.- planar_regions_boolean(regions, &[], BoolOp::Union, 1e-7)?;- let mut groups: Vec<Vec<Region2>> = regions.iter().cloned().map(|r| vec![r]).collect();- let mut remaining_pairs = 32_000_000usize;- while groups.len() > 1 {- let mut next = Vec::new();- let mut iter = groups.into_iter();+ check_regions(regions.iter(), 1e-7)?;+ if regions.is_empty() {+ return Err(KernelError::Invalid("empty planar material extrusion".into()));+ }+ // Balanced unions: each operand a sheet of regions apart from each other.+ let mut level = regions.iter().map(|r| sheets::sheet(std::slice::from_ref(r))).collect::<Result<Vec<_>>>()?;+ while level.len() > 1 {+ let mut next = Vec::with_capacity(level.len().div_ceil(2));+ let mut iter = level.into_iter();while let Some(a) = iter.next() {- if let Some(b) = iter.next() {- let count = |rs: &[Region2]| {- rs.iter().flat_map(|r| std::iter::once(&r.outer).chain(&r.holes)).fold(0usize, |n, l| n.saturating_add(l.segs.len()))- };- remaining_pairs = remaining_pairs- .checked_sub(count(&a).saturating_mul(count(&b)))- .ok_or_else(|| KernelError::Invalid("planar extrusion arrangement exceeds its work budget".into()))?;- next.push(planar_regions_boolean(&a, &b, BoolOp::Union, 1e-7)?);- } else {- next.push(a);+ match iter.next() {+ Some(b) => next.push(sheets::combine(&a, &b, BoolOp::Union)?.ok_or_else(|| KernelError::Failed("empty planar union".into()))?),+ None => next.push(a),}}- groups = next;+ level = next;}- let normalized = groups.pop().unwrap_or_default();- if normalized.is_empty() {- return Err(KernelError::Invalid("empty planar material extrusion".into()));+ let union = level.pop().ok_or_else(|| KernelError::Invalid("empty planar material extrusion".into()))?;+ let united = sheets::regions(&union, 1e-7)?;+ if united.touching {+ return Err(KernelError::Invalid("planar material pieces touch at a boundary".into()));}- // The separation test knows lines and arcs: free-form loops take part as their arcs.- let fitted = fit_free_form(&normalized, &mut Vec::new(), &mut 0)?;- for (i, a) in fitted.iter().enumerate() {- for b in fitted.iter().skip(i + 1) {- for s in std::iter::once(&a.outer).chain(&a.holes).flat_map(|l| &l.segs) {- for t in std::iter::once(&b.outer).chain(&b.holes).flat_map(|l| &l.segs) {- remaining_pairs = remaining_pairs- .checked_sub(1)- .ok_or_else(|| KernelError::Invalid("planar extrusion separation exceeds its work budget".into()))?;- let endpoints_touch = [s.start(), s.end()].iter().any(|p| t.point_at(closest_param(t, *p)).dist(*p) <= 1e-7)- || [t.start(), t.end()].iter().any(|p| s.point_at(closest_param(s, *p)).dist(*p) <= 1e-7);- if endpoints_touch || !crossings(s, t, 1e-7).is_empty() {- return Err(KernelError::Invalid("planar material pieces touch at a boundary".into()));- }- }- }- }+ if united.regions.is_empty() {+ return Err(KernelError::Invalid("empty planar material extrusion".into()));}- let pieces = crate::extrude(plane, &normalized, start, end)?;+ let pieces = crate::extrude(plane, &united.regions, start, end)?;crate::ops::join_pieces(pieces)?.ok_or_else(|| KernelError::Failed("empty planar material extrusion".into()))})}-/// What a section's segment is, through [`boolean2d_tagged`]: the free-form segment (by-/// number) the arc it is was fitted to, so the result's pieces of it get the exact curve back.-#[derive(Clone, Copy, Debug, PartialEq, Eq)]-struct Tag {- free: Option<usize>,-}--/// A segment that is no fitted arc.-const BLANK: Tag = Tag { free: None };--/// Regions with a tag for each segment: per region, per loop (outer, then holes), per segment.-#[derive(Clone, Debug, Default, PartialEq)]-struct Section {+/// The regions of a planar sheet, and whether two of its faces touch (share a vertex).+struct Regions {regions: Vec<Region2>,- tags: Vec<Vec<Vec<Tag>>>,+ touching: bool,}-impl Section {- /// Regions none of whose segments is a fitted arc.- fn untagged(regions: &[Region2]) -> Section {- let tags = regions.iter().map(|r| std::iter::once(&r.outer).chain(&r.holes).map(|l| vec![BLANK; l.segs.len()]).collect()).collect();- Section { regions: regions.to_vec(), tags }- }+#[cfg(feature = "smlib")]+mod sheets {+ use solidcraft_geom::Loop2;+ use solidcraft_geom::brep::Loop;+ use solidcraft_smlib::{BooleanOp, Brep};- /// The tag of segment `s` of loop `l` of region `r` (blank where missing).- fn tag(&self, r: usize, l: usize, s: usize) -> Tag {- self.tags.get(r).and_then(|t| t.get(l)).and_then(|t| t.get(s)).copied().unwrap_or(BLANK)+ use super::*;+ use crate::prism_curve::{Run, projected};++ fn failed(what: &str, e: impl std::fmt::Display) -> KernelError {+ KernelError::Failed(format!("SMLib planar regions: {what}: {e}"))}- /// The tags of region `r`'s loops, as long as its loops (blank where missing).- fn region_tags(&self, r: usize) -> Vec<Vec<Tag>> {- self.regions- .get(r)- .map(|reg| {- std::iter::once(®.outer)- .chain(®.holes)- .enumerate()- .map(|(l, lp)| (0..lp.segs.len()).map(|s| self.tag(r, l, s)).collect())- .collect()- })- .unwrap_or_default()+ /// `regions` (in the plane's own coordinates) as a sheet of planar faces on z = 0.+ pub(super) fn sheet(regions: &[Region2]) -> Result<Brep> {+ let curves = regions+ .iter()+ .flat_map(|r| std::iter::once(&r.outer).chain(&r.holes))+ .flat_map(|l| &l.segs)+ .map(|s| crate::smlib_sweeps::curve(&Plane::XY, s))+ .collect::<Result<Vec<_>>>()?;+ Brep::planar_faces(&curves).map_err(|e| failed("sheet", e))}- /// Every segment in order (regions, then loops) with its tag.- fn segments(&self) -> (Vec<Seg2>, Vec<Tag>) {- let mut out = (Vec::new(), Vec::new());- for (r, reg) in self.regions.iter().enumerate() {- for (l, lp) in std::iter::once(®.outer).chain(®.holes).enumerate() {- for (s, seg) in lp.segs.iter().enumerate() {- out.0.push(*seg);- out.1.push(self.tag(r, l, s));+ /// `a` and `b` combined by `op`; `None` when nothing is left.+ pub(super) fn combine(a: &Brep, b: &Brep, op: BoolOp) -> Result<Option<Brep>> {+ let op = match op {+ BoolOp::Union => BooleanOp::Union,+ BoolOp::Cut => BooleanOp::Subtract,+ BoolOp::Intersect => BooleanOp::Intersect,+ };+ a.boolean2d(b, op).map_err(|e| failed("2D boolean", e))+ }++ /// The faces of `sheet` as regions: each face's loops read off its edges exactly+ /// ([`projected`]), the one running counter-clockwise about the face's normal its outer loop,+ /// turned to run counter-clockwise in the plane and its holes clockwise. `tol` (mm, at least+ /// the record's) is how far an edge's curve may end from its vertices.+ pub(super) fn regions(sheet: &Brep, tol: f64) -> Result<Regions> {+ let record = sheet.to_native().map_err(|e| failed("export", e))?;+ let tol = tol.max(record.tolerance);+ let mut work = 2_000_000usize;+ let mut owner: std::collections::HashMap<u32, usize> = std::collections::HashMap::new();+ let mut touching = false;+ let mut out = Vec::with_capacity(record.faces.len());+ for (f, face) in record.faces.iter().enumerate() {+ let up = natural_normal(&face.surface).ok_or_else(|| failed("face", format!("face {f} is not on a plane")))?.z;+ if up.abs() < 1.0 - 1e-9 {+ return Err(failed("face", format!("face {f} is not in the plane of the regions")));+ }+ let mut outer = None;+ let mut holes = Vec::new();+ for (l, lp) in face.loops.iter().enumerate() {+ let Loop::Edges { edges } = lp else { return Err(failed("face", format!("face {f} has a vertex loop"))) };+ let mut segs = Vec::new();+ for e in edges {+ let run = Run::of(&record, e.edge as usize, e.forward).ok_or_else(|| failed("edge", format!("edge {} is missing", e.edge)))?;+ let read = projected(&run, &Plane::XY, tol, &mut work)+ .ok_or_else(|| failed("edge", format!("edge {} of face {f} is not read exactly in the plane", e.edge)))?;+ segs.extend(read);+ }+ for e in edges.iter().filter_map(|e| record.edges.get(e.edge as usize)) {+ for v in e.vertices {+ touching |= *owner.entry(v).or_insert(f) != f;+ }+ }+ let lp = Loop2 { segs };+ // Seen from the face's normal the outer loop runs counter-clockwise.+ if lp.signed_area() * up > 0.0 {+ if outer.replace(lp.ccw()).is_some() {+ return Err(failed("face", format!("face {f} has two outer loops (loop {l})")));+ }+ } else {+ holes.push(lp.ccw().reversed());}}+ let outer = outer.ok_or_else(|| failed("face", format!("face {f} has no outer loop")))?;+ out.push(Region2 { outer, holes });}- out+ Ok(Regions { regions: out, touching })}- /// Loops oriented: outers counter-clockwise, holes clockwise; the tags following their- /// segments.- fn oriented(&self) -> Section {- let turn = |lp: &Loop2, tags: Vec<Tag>, reverse: bool| -> (Loop2, Vec<Tag>) {- if reverse { (lp.reversed(), tags.into_iter().rev().collect()) } else { (lp.clone(), tags) }- };- let mut out = Section::default();- for (r, reg) in self.regions.iter().enumerate() {- let mut tags = self.region_tags(r).into_iter();- let (outer, outer_tags) = turn(®.outer, tags.next().unwrap_or_default(), reg.outer.signed_area() < 0.0);- let mut loop_tags = vec![outer_tags];- let mut holes = Vec::new();- for h in ®.holes {- let (hole, hole_tags) = turn(h, tags.next().unwrap_or_default(), h.signed_area() > 0.0);- holes.push(hole);- loop_tags.push(hole_tags);- }- out.regions.push(Region2 { outer, holes });- out.tags.push(loop_tags);+ /// 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]);+ match s {+ Surface::Plane { u_axis, v_axis, .. } => v(*u_axis).cross(v(*v_axis)).normalized(),+ Surface::PlaneThrough { origin, u_point, v_point } => (v(*u_point) - v(*origin)).cross(v(*v_point) - v(*origin)).normalized(),+ _ => None,}- out+ }+}++#[cfg(not(feature = "smlib"))]+mod sheets {+ use super::*;++ fn refused<T>() -> Result<T> {+ Err(KernelError::Failed("not supported yet: planar region booleans run on SMLib (build with the feature `smlib`)".into()))+ }++ /// A sheet stands for nothing without SMLib.+ pub(super) enum Sheet {}++ pub(super) fn sheet(_: &[Region2]) -> Result<Sheet> {+ refused()+ }++ pub(super) fn combine(a: &Sheet, _: &Sheet, _: BoolOp) -> Result<Option<Sheet>> {+ match *a {}+ }++ pub(super) fn regions(sheet: &Sheet, _: f64) -> Result<Regions> {+ match *sheet {}}}@@ -342,935 +315,11 @@ pub(crate) fn wall_along(surface: &Surface, d: Vec3, tol: f64, remaining: &mut ufalse}-/// Points where two segments cross (parameters on each), lines and arcs only.-///-/// Curves that touch within the tolerance (a line tangent to an arc, two circles tangent inside-/// or outside) meet at one point, taken from the centres: the foot of the centre on the line,-/// or the point on the line of centres. The intersection formulas' two roots there are rounding-/// noise spread along the curves by its square root (a 1e-12 mm error in a distance puts them-/// ±2e-6 mm from a 2 mm arc's tangent point), close enough to both curves to pass for two-/// crossings; when the noise falls the other way there is no root and the contact is missed.-fn crossings(s: &Seg2, t: &Seg2, tol: f64) -> Vec<(f64, f64)> {- let mut pts: Vec<Vec2> = Vec::new();- match (*s, *t) {- (Seg2::Line { a, b }, Seg2::Line { a: c, b: d }) => {- let (r, q) = (b - a, d - c);- let den = r.cross(q);- // Lines lying on one another within the tolerance do not cross: their ends split- // them. A hair from parallel they still meet at a point, anywhere along the overlap,- // and a split there leaves a piece shorter than the tolerance or a vertex that- // neither outline has.- let off = |p: Vec2, o: Vec2, dir: Vec2| (p - o).cross(dir).abs() / dir.len().max(1e-300);- let collinear = off(c, a, r) < tol && off(d, a, r) < tol || off(a, c, q) < tol && off(b, c, q) < tol;- if den.abs() > 1e-300 && !collinear {- let u = (c - a).cross(q) / den;- pts.push(a + r * u);- }- }- (Seg2::Line { a, b }, Seg2::Arc { center, radius, .. }) | (Seg2::Arc { center, radius, .. }, Seg2::Line { a, b }) => {- let dir = b - a;- let f = a - center;- let (qa, qb, qc) = (dir.dot(dir), 2.0 * f.dot(dir), f.dot(f) - radius * radius);- let disc = qb * qb - 4.0 * qa * qc;- if qa > 1e-300 {- let foot = a + dir * (-qb / (2.0 * qa));- if (foot.dist(center) - radius).abs() < tol {- pts.push(foot);- } else if disc >= -tol * tol * qa {- let sd = disc.max(0.0).sqrt();- for u in [(-qb - sd) / (2.0 * qa), (-qb + sd) / (2.0 * qa)] {- pts.push(a + dir * u);- }- }- }- }- (Seg2::Arc { center: c0, radius: r0, .. }, Seg2::Arc { center: c1, radius: r1, .. }) => {- let dd = c0.dist(c1);- if dd > 1e-12 && dd <= r0 + r1 + tol && dd >= (r0 - r1).abs() - tol {- // Circles of nearly one radius about nearly one centre lie on each other for a- // long way rather than touch at a point (centres 1000 tolerances apart: within- // the tolerance of each other over 5° of arc): those keep the general formula.- let inside = (dd - (r0 - r1).abs()).abs() < tol && dd > 1e3 * tol;- if (dd - (r0 + r1)).abs() < tol || inside {- pts.push(c0 + (c1 - c0) * (if inside && r1 > r0 { -r0 } else { r0 } / dd));- } else {- let a = (r0 * r0 - r1 * r1 + dd * dd) / (2.0 * dd);- let h = (r0 * r0 - a * a).max(0.0).sqrt();- let m = c0 + (c1 - c0) * (a / dd);- let perp = (c1 - c0).perp() * (1.0 / dd);- pts.push(m + perp * h);- pts.push(m - perp * h);- }- }- }- _ => {}- }- let mut out = Vec::new();- for p in pts {- let (u, v) = (closest_param(s, p), closest_param(t, p));- if s.point_at(u).dist(p) < tol && t.point_at(v).dist(p) < tol {- out.push((u, v));- }- }- out-}--/// Ray parity against analytic lines/arcs. Fragment classification must not depend on a-/// display chord tolerance: a tiny tool can sit between a circular boundary and its chords.-/// Loops are closed only within the chaining tolerance (an arrangement's own output joins its-/// pieces within `10 · tol`), so a gap where one line ends and the next begins is closed by a-/// straight connector: a ray through the gap would otherwise slip out of the loop without a-/// crossing and flip the parity of points level with the corner. Arcs decide their own ends-/// within an angular tolerance (below), so joints with an arc keep that rule.-fn inside_loop(lp: &Loop2, p: Vec2) -> bool {- // A ray through a vertex or grazing an arc's top or bottom is decided by the half-open- // rule, which needs both curves meeting there to agree on that point exactly. Arcs read- // back from a solid (a patterned hole's two halves) can disagree by a few ulps, so one half- // counts the touch and the other misses it. Move the ray off such points: a shift far below- // any modelling tolerance cannot change the answer for a point that is not on the loop.- let scale = 1.0 + p.x.abs().max(p.y.abs());- // A point clear of the loop's box (by more than the ray shifts below) is outside it: skip- // the costly tests, which a region with a thousand cut-outs runs for every probe (#732).- if let Some(b) = loop_box(lp)- && !b.inflated(scale * 1e-6).contains(p)- {- return false;- }- // A point on the loop keeps the half-open answer.- if lp.segs.iter().any(|s| s.point_at(closest_param(s, p)).dist(p) < scale * 1e-9) {- return inside_loop_ray(lp, p);- }- let grazes = |q: Vec2| {- let near = |y: f64| (y - q.y).abs() < scale * 1e-9;- lp.segs.iter().any(|s| {- near(s.start().y)- || match *s {- Seg2::Arc { center, radius, .. } => near(center.y + radius) || near(center.y - radius),- _ => false,- }- })- };- let ray = [0.0, 1.0, -1.0, 2.0, -2.0, 3.0, -3.0].into_iter().map(|k| Vec2::new(p.x, p.y + k * scale * 1e-7)).find(|q| !grazes(*q)).unwrap_or(p);- inside_loop_ray(lp, ray)-}--/// A box holding a loop of lines and arcs (an arc's whole circle); None for other curves.-fn loop_box(lp: &Loop2) -> Option<Aabb2> {- let mut b = Aabb2::EMPTY;- for seg in &lp.segs {- b = b.union(&match *seg {- Seg2::Line { a, b } => Aabb2 { min: Vec2::new(a.x.min(b.x), a.y.min(b.y)), max: Vec2::new(a.x.max(b.x), a.y.max(b.y)) },- Seg2::Arc { center, radius, .. } => Aabb2 { min: center, max: center }.inflated(radius.abs()),- _ => return None,- });- }- (!b.is_empty() && b.min.is_finite() && b.max.is_finite()).then_some(b)-}--/// [`inside_loop`] with the ray along +x from `p` taken as given.-fn inside_loop_ray(lp: &Loop2, p: Vec2) -> bool {- let mut odd = false;- let nexts = lp.segs.iter().skip(1).chain(lp.segs.first());- for (seg, next) in lp.segs.iter().zip(nexts) {- if let (Seg2::Line { b: a, .. }, Seg2::Line { a: b, .. }) = (*seg, *next)- && (a.y > p.y) != (b.y > p.y)- && a.x + (p.y - a.y) * (b.x - a.x) / (b.y - a.y) > p.x- {- odd = !odd;- }- match *seg {- Seg2::Line { a, b } => {- if (a.y > p.y) != (b.y > p.y) {- let x = a.x + (p.y - a.y) * (b.x - a.x) / (b.y - a.y);- if x > p.x {- odd = !odd;- }- }- }- Seg2::Arc { center, radius, start, sweep } => {- let y = (p.y - center.y) / radius;- if !(-1.0..=1.0).contains(&y) {- continue;- }- let a = y.asin();- let root = (1.0 - y * y).max(0.0).sqrt();- let full = (sweep.abs() - std::f64::consts::TAU).abs() < 1e-12;- for (i, (angle, x)) in [(a, center.x + radius * root), (std::f64::consts::PI - a, center.x - radius * root)].into_iter().enumerate() {- // A tangent has one geometric root. Interior tangencies contribute zero- // parity; a minimum at an endpoint follows the same half-open rule as lines.- if root == 0.0 && i == 1 {- continue;- }- if x <= p.x {- continue;- }- let mut delta = if sweep > 0.0 { angle - start } else { start - angle };- delta = delta.rem_euclid(std::f64::consts::TAU);- if (delta - std::f64::consts::TAU).abs() < 1e-12 {- delta = 0.0;- }- if delta > sweep.abs() + 1e-12 {- continue;- }- let dy = angle.cos() * sweep;- let tangent = dy.abs() < sweep.abs() * 1e-12;- let at_start = delta < 1e-12;- let at_end = (delta - sweep.abs()).abs() < 1e-12;- let crosses = if full {- !tangent- } else if at_start {- dy > 0.0 && !tangent || tangent && y < 0.0- } else if at_end {- dy < 0.0 && !tangent || tangent && y < 0.0- } else {- !tangent- };- if crosses {- odd = !odd;- }- }- }- _ => {- // Private prism callers only supply lines/arcs. Keep a controlled fallback- // for future internal callers; the public helper rejects other segment kinds.- let points = seg.polyline(1e-7);- for pair in points.windows(2) {- if let [a, b] = pair- && (a.y > p.y) != (b.y > p.y)- && a.x + (p.y - a.y) * (b.x - a.x) / (b.y - a.y) > p.x- {- odd = !odd;- }- }- }- }- }- odd-}--fn inside(regions: &[Region2], p: Vec2) -> bool {- regions.iter().any(|r| inside_loop(&r.outer, p) && !r.holes.iter().any(|h| inside_loop(h, p)))-}--/// Call only after proving the point is at least `tol` from the other boundary.-/// This sub-tolerance interior probe cannot cross that boundary, and avoids casting-/// exactly through fitted arc/line endpoints whose heights differ by roundoff.-fn inside_clear(regions: &[Region2], point: Vec2, tol: f64) -> bool {- inside(regions, point + Vec2::new(tol * 0.173, tol * 0.317))-}--/// Analytic projections avoid iterative searches at every planar boundary probe.-/// Other curve types keep the shared solver introduced on main.-fn closest_param(segment: &Seg2, point: Vec2) -> f64 {- match *segment {- Seg2::Line { a, b } => {- let direction = b - a;- let length2 = direction.dot(direction);- if length2 > 1e-300 && length2.is_finite() { ((point - a).dot(direction) / length2).clamp(0.0, 1.0) } else { 0.0 }- }- Seg2::Arc { center, radius, start, sweep } if radius > 0.0 && sweep.abs() > 1e-12 && sweep.abs() <= std::f64::consts::TAU + 1e-9 => {- let offset = point - center;- let delta = ((offset.y.atan2(offset.x) - start) * sweep.signum()).rem_euclid(std::f64::consts::TAU);- if delta <= sweep.abs() {- (delta / sweep.abs()).clamp(0.0, 1.0)- } else if segment.start().dist(point) <= segment.end().dist(point) {- 0.0- } else {- 1.0- }- }- _ => segment.closest_param(point),- }-}--/// The bounding box of a line or an arc, grown by twice the tolerance (and by the rounding of-/// its own corners). Whatever lies within the tolerance of the segment lies in the box. `None`-/// for other segments and for values that are not finite: no box, and nothing is skipped for it.-fn seg_box(s: &Seg2, tol: f64) -> Option<Aabb2> {- let mut pts = vec![s.start(), s.end()];- match *s {- Seg2::Line { .. } => {}- Seg2::Arc { center, radius, start, sweep } => {- // The axis extremes the arc passes.- for k in 0..4 {- let ang = k as f64 * std::f64::consts::FRAC_PI_2;- let delta =- if sweep >= 0.0 { (ang - start).rem_euclid(std::f64::consts::TAU) } else { (start - ang).rem_euclid(std::f64::consts::TAU) };- if delta <= sweep.abs() {- pts.push(center + Vec2::from_angle(ang) * radius);- }- }- }- _ => return None,- }- let g = tol * 2.0 + 1e-12 * pts.iter().fold(0.0, |m: f64, p| m.max(p.x.abs()).max(p.y.abs()));- (pts.iter().all(|p| p.is_finite()) && g.is_finite()).then(|| pts.iter().copied().collect::<Aabb2>().inflated(g))-}--fn boxes_meet(a: Option<Aabb2>, b: Option<Aabb2>) -> bool {- match (a, b) {- (Some(a), Some(b)) => a.meets(&b),- _ => true,- }-}--fn box_holds(b: Option<Aabb2>, p: Vec2) -> bool {- b.is_none_or(|b| b.contains(p))-}--/// Distance from `p` to the nearest of `segs` whose box holds it: infinite when none does (no-/// segment is within the tolerance of `p` then).-fn near_dist(segs: &[Seg2], boxes: &[Option<Aabb2>], p: Vec2) -> f64 {- segs.iter().zip(boxes).filter(|(_, b)| box_holds(**b, p)).map(|(s, _)| s.point_at(closest_param(s, p)).dist(p)).fold(f64::INFINITY, f64::min)-}--/// Direction of the first of `segs` through `p` (within `tol`), as it runs.-fn near_dir(segs: &[Seg2], boxes: &[Option<Aabb2>], p: Vec2, tol: f64) -> Option<Vec2> {- let (s, t) = segs- .iter()- .zip(boxes)- .filter(|(_, b)| box_holds(**b, p))- .map(|(s, _)| (s, closest_param(s, p)))- .find(|(s, t)| s.point_at(*t).dist(p) < tol)?;- s.derivative(t).normalized()-}--/// 2D boolean of regions bounded by lines and arcs.-fn boolean2d(a: &[Region2], b: &[Region2], op: BoolOp, tol: f64) -> Option<Vec<Region2>> {- boolean2d_tagged(&Section::untagged(a), &Section::untagged(b), op, tol).map(|s| s.regions)-}--/// [`boolean2d`] of sections. Free-form segments (a font's curves) take part as arcs within-/// [`PLANAR_FIT_TOL`]; each piece of one in the result is the exact curve again, ending where-/// it exactly meets the segment next to it (see [`exact_again`]).-fn boolean2d_tagged(a: &Section, b: &Section, op: BoolOp, tol: f64) -> Option<Section> {- let line_arc = |s: &Section| s.regions.iter().all(Region2::is_line_arc);- if line_arc(a) && line_arc(b) {- return boolean2d_arcs(a, b, op, tol);- }- let mut sources = Vec::new();- let (fa, fb) = (fitted(a, &mut sources, PLANAR_FIT_TOL)?, fitted(b, &mut sources, PLANAR_FIT_TOL)?);- let out = boolean2d_arcs(&fa, &fb, op, tol)?;- Some(exact_again(out, &sources, tol))-}--/// `s` with each free-form segment replaced by lines and arcs within `fit`, tagged with its-/// number in `sources` (where it is put).-fn fitted(s: &Section, sources: &mut Vec<Seg2>, fit: f64) -> Option<Section> {- let mut out = Section::default();- let mut pieces = 0usize;- for (r, reg) in s.regions.iter().enumerate() {- let mut loops = Vec::new();- let mut tags = Vec::new();- for (l, lp) in std::iter::once(®.outer).chain(®.holes).enumerate() {- let (mut segs, mut ts) = (Vec::new(), Vec::new());- for (i, seg) in lp.segs.iter().enumerate() {- if seg.is_line_or_arc() {- segs.push(*seg);- ts.push(s.tag(r, l, i));- continue;- }- let arcs = seg.fit_arcs(fit)?;- pieces = pieces.checked_add(arcs.len()).filter(|n| *n <= MAX_PLANAR_SEGMENTS)?;- let n = arcs.len();- ts.extend(std::iter::repeat_n(Tag { free: Some(sources.len()) }, n));- segs.extend(arcs);- sources.push(*seg);- }- loops.push(Loop2 { segs });- tags.push(ts);- }- let mut loops = loops.into_iter();- out.regions.push(Region2 { outer: loops.next()?, holes: loops.collect() });- out.tags.push(tags);- }- Some(out)-}--/// A loop's piece in [`exact_again`]: a run of arcs fitted to free-form segment `src`, standing-/// for its exact curve from parameter `t0` to `t1` (`t1 < t0`: run backwards), from `a` to `b`;-/// or a line or arc as it is.-#[derive(Clone, Copy)]-enum Piece {- Exact { src: usize, t0: f64, t1: f64, a: Vec2, b: Vec2, tag: Tag },- Plain(Seg2, Tag),-}--impl Piece {- fn end(&self) -> Vec2 {- match self {- Piece::Exact { b, .. } => *b,- Piece::Plain(s, _) => s.end(),- }- }-- /// The piece ending at `at` (an exact curve: at its parameter `t`, when given).- fn set_end(&mut self, t: Option<f64>, at: Vec2) {- match self {- Piece::Exact { t1, b, .. } => {- if let Some(t) = t {- *t1 = t;- }- *b = at;- }- Piece::Plain(s, _) => *s = seg_with_ends(s, s.start(), at),- }- }-- /// The piece starting at `at` (an exact curve: at its parameter `t`, when given).- fn set_start(&mut self, t: Option<f64>, at: Vec2) {- match self {- Piece::Exact { t0, a, .. } => {- if let Some(t) = t {- *t0 = t;- }- *a = at;- }- Piece::Plain(s, _) => *s = seg_with_ends(s, at, s.end()),- }- }-}--/// `s` running from `a` to `b` instead (points on it or a hair off it): a line between them, an-/// arc of the same circle, a free-form segment with those end control points.-fn seg_with_ends(s: &Seg2, a: Vec2, b: Vec2) -> Seg2 {- match *s {- Seg2::Line { .. } => Seg2::Line { a, b },- Seg2::Arc { center, radius, start, sweep } => {- let new_start = (a - center).angle();- let end = start + sweep;- // The same way round, through the same part of the circle.- let shift = |x: f64, near: f64| x + ((near - x) / std::f64::consts::TAU).round() * std::f64::consts::TAU;- let s0 = shift(new_start, start);- let s1 = shift((b - center).angle(), end);- Seg2::Arc { center, radius, start: s0, sweep: s1 - s0 }- }- Seg2::Cubic { p1, p2, .. } => Seg2::Cubic { p0: a, p1, p2, p3: b },- Seg2::Conic { apex, w, .. } => Seg2::Conic { a, apex, b, w },- Seg2::Bezier { n, mut p } => {- if let Some(x) = p.first_mut() {- *x = a;- }- if let Some(x) = p.get_mut(n as usize) {- *x = b;- }- Seg2::Bezier { n, p }- }- }-}--/// The exact piece of `src` from parameter `t0` to `t1` (either way round), from `a` to `b`.-fn trimmed(src: &Seg2, t0: f64, t1: f64, a: Vec2, b: Vec2) -> Seg2 {- let (lo, hi) = (t0.min(t1), t0.max(t1));- let mut s = *src;- if lo > 1e-12 {- s = s.split_at(lo).1;- }- if hi < 1.0 - 1e-12 {- // Splitting a conic renormalises its weights, which moves its parameters: the second- // split is found on the piece.- let at = closest_param(&s, src.point_at(hi));- if at < 1.0 - 1e-12 {- s = s.split_at(at).0;- }- }- if t0 <= t1 { seg_with_ends(&s, a, b) } else { seg_with_ends(&s.reversed(), a, b) }-}--/// Where curve `p` near its parameter `t` meets `q` near its parameter `u`, by Newton's method:-/// their parameters there, or `None` when the crossing doesn't settle within `near` of `p(t)`.-fn meet(p: &Seg2, t: f64, q: &Seg2, u: f64, near: f64) -> Option<(f64, f64)> {- let (mut t, mut u) = (t, u);- let start = p.point_at(t);- let scale = 1.0 + start.x.abs().max(start.y.abs());- for _ in 0..50 {- let f = p.point_at(t) - q.point_at(u);- if f.len() < 1e-14 * scale {- break;- }- // P(t) - Q(u) = f; the step solves [P'(t), -Q'(u)] (dt, du) = -f.- let (dp, dq) = (p.derivative(t), q.derivative(u));- let det = -dp.cross(dq);- if !(det.abs() > 1e-300 && det.is_finite()) {- return None;- }- t = (t + f.cross(dq) / det).clamp(0.0, 1.0);- u = (u + f.cross(dp) / det).clamp(0.0, 1.0);- }- let (x, y) = (p.point_at(t), q.point_at(u));- (x.dist(y) < 1e-9 * scale && x.dist(start) < near).then_some((t, u))-}--/// The whole line or circle a line or arc lies on (as a segment reaching past it), what an exact-/// crossing with a curve is looked for on.-fn carrier(s: &Seg2) -> Option<Seg2> {- match *s {- Seg2::Line { a, b } => Some(Seg2::Line { a: a - (b - a), b: b + (b - a) }),- Seg2::Arc { center, radius, start, sweep } => {- let turn = sweep.signum() * std::f64::consts::PI;- Some(Seg2::Arc { center, radius, start: start + sweep * 0.5 - turn, sweep: 2.0 * turn })- }- _ => None,- }-}--/// The exact curves back in the result of a boolean of [`fitted`] sections: each run of arcs-/// fitted to one free-form segment becomes that segment's exact piece, and where a run ends on-/// another segment (a cut across the curve) both end at their exact crossing. Where that-/// crossing can't be found they end where the arrangement put them, within-/// [`PLANAR_FIT_TOL`] of it.-fn exact_again(out: Section, sources: &[Seg2], tol: f64) -> Section {- let near = (PLANAR_FIT_TOL + tol) * 10.0;- let mut res = Section::default();- for (r, reg) in out.regions.iter().enumerate() {- let tags = out.region_tags(r);- let mut loops = Vec::new();- let mut loop_tags = Vec::new();- for (l, lp) in std::iter::once(®.outer).chain(®.holes).enumerate() {- let (segs, ts) = exact_loop(lp, tags.get(l).map(Vec::as_slice).unwrap_or(&[]), sources, near);- // A sliver the arrangement found where a curve's arcs nearly touch another part of- // the outline (at the waist of a 3) closes up to nothing on the exact curves: it- // encloses nothing and would make edges with no length, so it is left out.- if segs.iter().map(Seg2::length).sum::<f64>() <= near {- if l == 0 {- break;- }- continue;- }- loops.push(Loop2 { segs });- loop_tags.push(ts);- }- let mut loops = loops.into_iter();- let Some(outer) = loops.next() else { continue };- res.regions.push(Region2 { outer, holes: loops.collect() });- res.tags.push(loop_tags);- }- res-}--/// One loop of [`exact_again`]: its segments and their tags.-fn exact_loop(lp: &Loop2, tags: &[Tag], sources: &[Seg2], near: f64) -> (Vec<Seg2>, Vec<Tag>) {- let n = lp.segs.len();- let tag = |_: usize| BLANK;- let free = |i: usize| tags.get(i).and_then(|t| t.free);- let plain = || (lp.segs.clone(), (0..n).map(tag).collect::<Vec<_>>());- // Start at the first segment of a run (a loop that is one run stays as it is).- let Some(first) = (0..n).find(|&i| free(i).is_none() || free(i) != free((i + n - 1) % n)) else { return plain() };- let mut pieces: Vec<Piece> = Vec::new();- let mut k = 0;- while k < n {- let i = (first + k) % n;- let Some(seg) = lp.segs.get(i) else { return plain() };- let Some((f, src)) = free(i).and_then(|f| sources.get(f).map(|s| (f, s))) else {- pieces.push(Piece::Plain(*seg, tag(i)));- k += 1;- continue;- };- let mut j = k;- while j + 1 < n && free((first + j + 1) % n) == Some(f) {- j += 1;- }- let Some(last) = lp.segs.get((first + j) % n) else { return plain() };- // A run reaching the curve's end is the curve to its end, exactly: the same curve the- // walls over it are read from, which a parameter found by projection (a hair short of 1)- // would cut short into a different one.- let at = |p: Vec2| {- if p.dist(src.start()) < near {- 0.0- } else if p.dist(src.end()) < near {- 1.0- } else {- closest_param(src, p)- }- };- let (t0, t1) = (at(seg.start()), at(last.end()));- if (t1 - t0).abs() < 1e-9 {- // A sliver of the curve: its arcs as they are, or, shorter than the tolerance (where- // a curve lies on another, as when the same letters are cut again), nothing: its- // neighbours meet where it was, and as an edge it would have no length.- let length: f64 = (k..=j).filter_map(|m| lp.segs.get((first + m) % n)).map(Seg2::length).sum();- if length > near {- for m in k..=j {- let q = (first + m) % n;- pieces.push(Piece::Plain(*lp.segs.get(q).unwrap_or(seg), tag(q)));- }- }- } else {- pieces.push(Piece::Exact { src: f, t0, t1, a: src.point_at(t0), b: src.point_at(t1), tag: BLANK });- }- k = j + 1;- }- // Each joint at an exact curve: both sides end at the same point, the exact crossing where- // the curve is cut, its own end point where it ends.- if pieces.is_empty() {- return plain();- }- let m = pieces.len();- let inner = |t: f64| t > 1e-9 && t < 1.0 - 1e-9;- for i in 0..m {- let (Some(p), Some(q)) = (pieces.get(i).copied(), pieces.get((i + 1) % m).copied()) else { continue };- let joint = p.end();- let src = |f: usize| sources.get(f);- let found = match (p, q) {- (Piece::Exact { src: f, t1, .. }, Piece::Exact { src: g, t0, .. }) if f != g && (inner(t1) || inner(t0)) => {- src(f).zip(src(g)).and_then(|(x, y)| meet(x, t1, y, t0, near).map(|(a, b)| (Some(a), Some(b), x.point_at(a))))- }- (Piece::Exact { src: f, t1, .. }, Piece::Plain(s, _)) if inner(t1) => src(f)- .zip(carrier(&s))- .and_then(|(x, c)| meet(x, t1, &c, closest_param(&c, joint), near).map(|(a, _)| (Some(a), None, x.point_at(a)))),- (Piece::Plain(s, _), Piece::Exact { src: f, t0, .. }) if inner(t0) => src(f)- .zip(carrier(&s))- .and_then(|(x, c)| meet(x, t0, &c, closest_param(&c, joint), near).map(|(a, _)| (None, Some(a), x.point_at(a)))),- _ => None,- };- // No crossing to refine (or none found): both end where the curve does.- let found = found.or(match (p, q) {- (Piece::Exact { b, .. }, _) => Some((None, None, b)),- (_, Piece::Exact { a, .. }) => Some((None, None, a)),- _ => None,- });- let Some((x, y, at)) = found else { continue };- if let Some(p) = pieces.get_mut(i) {- p.set_end(x, at);- }- if let Some(q) = pieces.get_mut((i + 1) % m) {- q.set_start(y, at);- }- }- let mut segs = Vec::with_capacity(m);- let mut ts = Vec::with_capacity(m);- for p in pieces {- match p {- Piece::Exact { src, t0, t1, a, b, tag } => match sources.get(src) {- Some(s) => {- segs.push(trimmed(s, t0, t1, a, b));- ts.push(tag);- }- None => return plain(),- },- Piece::Plain(s, t) => {- segs.push(s);- ts.push(t);- }- }- }- // The loop closed exactly: where a segment ends a hair from where the next starts (a font's- // nearly round curve read as an arc ends a few hundredths of a micron off the curve after- // it), the one that is not an arc moves its end onto the arc's (an arc's ends stay on its- // circle). Two arcs are left as they meet, as a boolean of lines and arcs leaves them.- let m = segs.len();- for i in 0..m {- let j = (i + 1) % m;- let (Some(x), Some(y)) = (segs.get(i).copied(), segs.get(j).copied()) else { continue };- let gap = x.end().dist(y.start());- if gap == 0.0 || gap > near {- continue;- }- let arc = |s: &Seg2| matches!(s, Seg2::Arc { .. });- if !arc(&y) {- if let Some(s) = segs.get_mut(j) {- *s = seg_with_ends(&y, x.end(), y.end());- }- } else if !arc(&x)- && let Some(s) = segs.get_mut(i)- {- *s = seg_with_ends(&x, x.start(), y.start());- }- }- (segs, ts)-}--/// The boolean of sections of lines and arcs alone ([`boolean2d_tagged`]).-fn boolean2d_arcs(a: &Section, b: &Section, op: BoolOp, tol: f64) -> Option<Section> {- let count =- |rs: &[Region2]| rs.iter().flat_map(|r| std::iter::once(&r.outer).chain(&r.holes)).fold(0usize, |n, lp| n.saturating_add(lp.segs.len()));- let (na, nb) = (count(&a.regions), count(&b.regions));- if na.saturating_add(nb) > MAX_PLANAR_SEGMENTS || na.saturating_mul(nb) > MAX_PLANAR_PAIRS {- return None;- }- let (a, b) = (a.oriented(), b.oriented());- let ((sa, ta), (sb, tb)) = (a.segments(), b.segments());- let (a, b) = (a.regions, b.regions);- if sa.iter().chain(&sb).any(|s| !matches!(s, Seg2::Line { .. } | Seg2::Arc { .. })) {- return None;- }- // Only segments whose bounding boxes meet can cross, touch or lie on each other: the other- // pairs skip the exact tests (a closest-point search each).- let (box_a, box_b): (Vec<_>, Vec<_>) = (sa.iter().map(|s| seg_box(s, tol)).collect(), sb.iter().map(|s| seg_box(s, tol)).collect());- let apart = |i: usize, j: usize| !boxes_meet(box_a.get(i).copied().flatten(), box_b.get(j).copied().flatten());- // Split every segment where it crosses the other side's boundary.- let mut cut_a: Vec<Vec<f64>> = vec![Vec::new(); sa.len()];- let mut cut_b: Vec<Vec<f64>> = vec![Vec::new(); sb.len()];- let mut events = 0usize;- for (i, s) in sa.iter().enumerate() {- for (j, t) in sb.iter().enumerate() {- if apart(i, j) {- continue;- }- for (u, v) in crossings(s, t, tol) {- events += 2;- if events > MAX_PLANAR_EVENTS {- return None;- }- cut_a.get_mut(i)?.push(u);- cut_b.get_mut(j)?.push(v);- }- }- }- // Ends of the other side's segments lying on a segment split it too (touching corners).- for (i, s) in sa.iter().enumerate() {- for (j, t) in sb.iter().enumerate() {- if apart(i, j) {- continue;- }- for p in [t.start(), t.end()] {- let u = closest_param(s, p);- if s.point_at(u).dist(p) < tol {- events += 1;- if events > MAX_PLANAR_EVENTS {- return None;- }- cut_a.get_mut(i)?.push(u);- }- }- }- }- for (j, t) in sb.iter().enumerate() {- for (i, s) in sa.iter().enumerate() {- if apart(i, j) {- continue;- }- for p in [s.start(), s.end()] {- let v = closest_param(t, p);- if t.point_at(v).dist(p) < tol {- events += 1;- if events > MAX_PLANAR_EVENTS {- return None;- }- cut_b.get_mut(j)?.push(v);- }- }- }- }- // The loops below are chained by joining pieces whose ends lie within `near` of each other,- // so to them a piece shorter than that runs from a point back to the same point: a cut that- // would leave one, at either end of what is left of the segment, is not made. Two edges- // 0.57° apart that share a corner up to rounding cross a hundred times that rounding short- // of it; split there, the sliver between the crossing and the corner was taken for a- // second way out of the corner and closed as a loop of its own.- let near = tol * 10.0;- let pieces = |s: &Seg2, cuts: &mut Vec<f64>| -> Vec<Seg2> {- cuts.sort_by(f64::total_cmp);- let mut out = Vec::new();- let mut rest = *s;- let mut done = 0.0;- for &c in cuts.iter() {- if c <= done + 1e-9 || c >= 1.0 - 1e-9 {- continue;- }- let local = (c - done) / (1.0 - done);- let (x, y) = rest.split_at(local);- if x.length() > near && y.length() > near {- out.push(x);- rest = y;- done = c;- }- }- out.push(rest);- out- };- let mut kept: Vec<(Seg2, Tag)> = Vec::new();- // A's pieces.- for (i, s) in sa.iter().enumerate() {- if cut_a.get(i)?.len() > MAX_PLANAR_SEGMENTS {- return None;- }- let split = pieces(s, cut_a.get_mut(i)?);- let tag = ta.get(i).copied().unwrap_or(BLANK);- for p in split {- let m = p.point_at(0.5);- let on = near_dist(&sb, &box_b, m) < tol;- let keep = if on {- let same = near_dir(&sb, &box_b, m, tol).is_some_and(|d| d.dot(p.derivative(0.5)) > 0.0);- match op {- BoolOp::Union | BoolOp::Intersect => same,- BoolOp::Cut => !same,- }- } else {- let ins = inside_clear(&b, m, tol);- match op {- BoolOp::Union | BoolOp::Cut => !ins,- BoolOp::Intersect => ins,- }- };- if keep {- if kept.len() >= MAX_PLANAR_SEGMENTS {- return None;- }- kept.push((p, tag));- }- }- }- // B's pieces (coincident ones were decided with A's).- for (j, t) in sb.iter().enumerate() {- if cut_b.get(j)?.len() > MAX_PLANAR_SEGMENTS {- return None;- }- let split = pieces(t, cut_b.get_mut(j)?);- let tag = tb.get(j).copied().unwrap_or(BLANK);- for p in split {- let m = p.point_at(0.5);- if near_dist(&sa, &box_a, m) < tol {- continue;- }- let ins = inside_clear(&a, m, tol);- if kept.len() >= MAX_PLANAR_SEGMENTS {- return None;- }- match op {- BoolOp::Union if !ins => kept.push((p, tag)),- BoolOp::Intersect if ins => kept.push((p, tag)),- BoolOp::Cut if ins => kept.push((p.reversed(), tag)),- _ => {}- }- }- }- // Chain into loops. Where several kept pieces leave the point a loop has reached (outlines- // pinching at a vertex on an edge, a circle tangent to a side, two corners touching), the- // loop takes the one keeping the material on its left most tightly, so that pieces of- // material meeting only at that point close as loops of their own; returning to its start,- // a loop closes only when that is the tightest turn too. A loop that still passes a point- // twice (a hole touching the outline) is split there into simple loops.- let mut loops: Vec<(Loop2, Vec<Tag>)> = Vec::new();- let mut used = vec![false; kept.len()];- for start in 0..kept.len() {- if used.get(start).copied().unwrap_or(true) {- continue;- }- let (seg, tag) = *kept.get(start)?;- let (mut segs, mut tags) = (vec![seg], vec![tag]);- if let Some(u) = used.get_mut(start) {- *u = true;- }- let first = seg.start();- let mut guard = 0;- loop {- guard += 1;- if guard > kept.len() + 2 {- return None;- }- let last = *segs.last()?;- let end = last.end();- let full_circle =- segs.first().is_some_and(|s| matches!(s, Seg2::Arc { sweep, .. } if (sweep.abs() - std::f64::consts::TAU).abs() < 1e-9));- let closes = end.dist(first) < near && (segs.len() > 1 || full_circle);- let leaving: Vec<usize> =- (0..kept.len()).filter(|k| !used.get(*k).copied().unwrap_or(true) && kept[*k].0.start().dist(end) < near).collect();- let next = match leaving.as_slice() {- [] if end.dist(first) < near => break,- [] => return None,- [only] if !closes => *only,- _ => {- // The loop's own first piece stands for closing it.- let mut out: Vec<Seg2> = leaving.iter().map(|k| kept[*k].0).collect();- if closes {- out.push(*segs.first()?);- }- let pick = tightest_left(&last, &out)?;- match leaving.get(pick) {- Some(k) => *k,- None => break,- }- }- };- let (seg, tag) = *kept.get(next)?;- if let Some(u) = used.get_mut(next) {- *u = true;- }- segs.push(seg);- tags.push(tag);- }- for (l, t) in simple_loops(Loop2 { segs }, tags, near) {- if l.signed_area().abs() > tol * tol {- loops.push((l, t));- }- }- }- // Outers (counter-clockwise) take the holes they contain, the smallest first.- let (mut outers, holes): (Vec<(Loop2, Vec<Tag>)>, Vec<(Loop2, Vec<Tag>)>) = loops.into_iter().partition(|(l, _)| l.signed_area() > 0.0);- outers.sort_by(|x, y| x.0.signed_area().abs().total_cmp(&y.0.signed_area().abs()));- let mut out = Section::default();- for (o, tags) in outers {- out.regions.push(Region2 { outer: o, holes: Vec::new() });- out.tags.push(vec![tags]);- }- for (h, tags) in holes {- let p = h.segs.first()?.point_at(0.5);- let r = out.regions.iter().position(|r| inside_loop(&r.outer, p) && r.outer.signed_area().abs() > h.signed_area().abs())?;- out.regions.get_mut(r)?.holes.push(h);- out.tags.get_mut(r)?.push(tags);- }- Some(out)-}--/// Of the pieces in `out` leaving the point where `incoming` ends, the one turning most to the-/// left: the largest counter-clockwise angle from the way back along `incoming`. A loop with-/// its material on its left that always takes it encloses the least, so material meeting-/// another piece only at a point closes there as a loop of its own.-///-/// Directions are read a short way along each piece (the same distance on all, a twentieth of-/// the shortest), not from tangents: a circle tangent to a line leaves the point along the-/// line, and only its curvature says which side it turns to. The pieces of an arrangement-/// don't cross, and none turns more than a twentieth of its sweep within that distance, so the-/// order the points lie in is the order the pieces leave in.-fn tightest_left(incoming: &Seg2, out: &[Seg2]) -> Option<usize> {- let shortest = out.iter().map(Seg2::length).fold(incoming.length(), f64::min);- let h = shortest * 0.05;- if !(h > 0.0) || !h.is_finite() {- return None;- }- let at = incoming.end();- let back = incoming.point_at(1.0 - h / incoming.length()) - at;- let turn = |s: &Seg2| {- let d = s.point_at(h / s.length()) - at;- let a = back.cross(d).atan2(back.dot(d));- if a < 0.0 { a + std::f64::consts::TAU } else { a }- };- (0..out.len()).max_by(|x, y| turn(&out[*x]).total_cmp(&turn(&out[*y])))-}--/// A closed loop split where it passes a point twice (within `near`) into loops that pass-/// every point once, with their segments' tags. Counter-clockwise pieces are material, the-/// others holes in it: a hole touching the outline at one point, or two pieces of material-/// meeting at a corner, come out as two loops sharing that point.-fn simple_loops(lp: Loop2, tags: Vec<Tag>, near: f64) -> Vec<(Loop2, Vec<Tag>)> {- let mut todo = vec![(lp.segs, tags)];- let mut out = Vec::new();- // Each split leaves two shorter loops, so the work is bounded by the segment count.- while let Some((segs, tags)) = todo.pop() {- let n = segs.len();- let repeat = (0..n).find_map(|i| {- let p = segs.get(i)?.start();- (i + 1..n).find(|j| segs.get(*j).is_some_and(|s| s.start().dist(p) < near)).map(|j| (i, j))- });- match repeat {- Some((i, j)) if j > i => {- let part = |v: &[Seg2], r: std::ops::Range<usize>| v.get(r).unwrap_or(&[]).to_vec();- let part_t = |v: &[Tag], r: std::ops::Range<usize>| v.get(r).unwrap_or(&[]).to_vec();- let inner = (part(&segs, i..j), part_t(&tags, i..j));- let outer = ([part(&segs, j..n), part(&segs, 0..i)].concat(), [part_t(&tags, j..n), part_t(&tags, 0..i)].concat());- todo.push(inner);- todo.push(outer);- }- _ => out.push((Loop2 { segs }, tags)),- }- }- out-}-#[cfg(test)]+#[allow(clippy::unwrap_used, clippy::panic)]mod planar_tests {use super::*;+ use solidcraft_geom::Loop2;#[test]fn shared_arc_line_endpoint_roundoff_does_not_open_a_union() {let a = Region2 { outer: Loop2::polygon(&[Vec2::new(-2., 0.), Vec2::new(2., 0.), Vec2::new(2., 2.), Vec2::new(-2., 2.)]), holes: vec![] };@@ -1302,31 +351,6 @@ mod planar_tests {assert!((result[0].area() - a.area() - b.area()).abs() < 1e-6);}}- #[test]- fn analytic_projection_keeps_clamped_lines_and_wrapped_arcs() {- let line = Seg2::Line { a: Vec2::new(2., 3.), b: Vec2::new(5., 7.) };- for (point, expected) in [(Vec2::new(-1., -1.), 0.), (Vec2::new(3.5, 5.), 0.5), (Vec2::new(8., 11.), 1.)] {- assert!((closest_param(&line, point) - expected).abs() < 1e-12);- }- for start in [-7., -0.5, 3., 7.] {- for sweep in [-std::f64::consts::TAU, -5., -0.2, 0.2, 5., std::f64::consts::TAU] {- let arc = Seg2::Arc { center: Vec2::new(2., -3.), radius: 4., start, sweep };- for index in 0..128 {- let angle = index as f64 * std::f64::consts::TAU / 128.;- let point = Vec2::new(2., -3.) + Vec2::new(angle.cos(), angle.sin()) * 6.;- let nearest = arc.point_at(closest_param(&arc, point));- // Includes both signs, sweeps over pi, seam crossings and endpoint clamps.- for sample in 0..=128 {- assert!(nearest.dist(point) <= arc.point_at(sample as f64 / 128.).dist(point) + 1e-10);- }- }- for t in [0., 0.25, 0.5, 0.75, 1.] {- let point = arc.point_at(t);- assert!(arc.point_at(closest_param(&arc, point)).dist(point) < 1e-10);- }- }- }- }fn rectangle(a: Vec2, b: Vec2) -> Region2 {Region2 { outer: Loop2::polygon(&[a, Vec2::new(b.x, a.y), b, Vec2::new(a.x, b.y)]), holes: vec![] }}@@ -1369,7 +393,6 @@ mod planar_tests {let circles = [Vec2::ZERO, Vec2::new(10.0, 0.0)].map(|center| Region2 { outer: Loop2::circle(center, 5.0), holes: vec![] });assert!(extrude_planar_regions(&plane, &circles, 0.0, 2.0).is_err());}-/// An ellipse about `c` with semi-axes `a` (along x) and `b`, as four exact conics.fn ellipse(c: Vec2, a: f64, b: f64) -> Loop2 {let corners = [c + Vec2::new(a, 0.0), c + Vec2::new(0.0, b), c - Vec2::new(a, 0.0), c - Vec2::new(0.0, b)];@@ -1378,9 +401,8 @@ mod planar_tests {segs: (0..4).map(|i| Seg2::Conic { a: corners[i], apex: corners[i] + corners[(i + 1) % 4] - c, b: corners[(i + 1) % 4], w }).collect(),}}-#[test]- fn free_form_cut_outs_stay_exact_when_whole_and_follow_arcs_when_cut() {+ fn free_form_cut_outs_stay_exact_whole_or_cut() {let plate = rectangle(Vec2::ZERO, Vec2::new(100.0, 60.0));let hole = Region2 { outer: ellipse(Vec2::new(40.0, 30.0), 15.0, 8.0), holes: vec![] };let out = planar_regions_boolean(std::slice::from_ref(&plate), std::slice::from_ref(&hole), BoolOp::Cut, 1e-7).unwrap();@@ -1398,17 +420,18 @@ mod planar_tests {let taken = planar_regions_boolean(std::slice::from_ref(&plate), std::slice::from_ref(&hole), BoolOp::Intersect, 1e-7).unwrap();assert!(taken.len() == 1 && taken[0].outer.segs.iter().all(|s| hole.outer.segs.contains(s)), "{taken:?}");// An ellipse centred on the plate's edge makes a notch of half the ellipse: its part- // inside follows arcs within the fit tolerance (times half the perimeter, 37 mm).+ // inside is the ellipse's own conics, cut where they cross the edge, so the notch takes+ // exactly half the ellipse.let over = Region2 { outer: ellipse(Vec2::new(100.0, 30.0), 15.0, 8.0), holes: vec![] };let out = planar_regions_boolean(std::slice::from_ref(&plate), std::slice::from_ref(&over), BoolOp::Cut, 1e-7).unwrap();assert_eq!(out.len(), 1);- assert!(out[0].holes.is_empty() && out[0].outer.is_line_arc());+ assert!(out[0].holes.is_empty() && !out[0].outer.is_line_arc());let notched = 6000.0 - std::f64::consts::PI * 15.0 * 8.0 / 2.0;- assert!((out[0].area() - notched).abs() < PLANAR_FIT_TOL * 37.0, "{} vs {notched}", out[0].area());- // Two ellipses that overlap join into one outline of arcs; apart, both stay exact.+ assert!((out[0].area() - notched).abs() < 1e-6, "{} vs {notched}", out[0].area());+ // Two ellipses that overlap join into one outline of their conics; apart, both stay whole.let beside = |dx: f64| Region2 { outer: ellipse(Vec2::new(40.0 + dx, 30.0), 15.0, 8.0), holes: vec![] };let joined = planar_regions_boolean(std::slice::from_ref(&hole), &[beside(20.0)], BoolOp::Union, 1e-7).unwrap();- assert!(joined.len() == 1 && joined[0].outer.is_line_arc(), "{joined:?}");+ assert!(joined.len() == 1 && joined[0].outer.segs.iter().all(|s| !s.is_line_or_arc()), "{joined:?}");let apart = planar_regions_boolean(std::slice::from_ref(&hole), &[beside(40.0)], BoolOp::Union, 1e-7).unwrap();assert!(apart.len() == 2 && apart.iter().all(|r| r.outer.segs.len() == 4 && !r.outer.is_line_arc()), "{apart:?}");// The flat material extrudes with the exact elliptic wall: four conic faces, two caps.@@ -1417,41 +440,14 @@ mod planar_tests {let v = crate::measure(&body).unwrap().volume;assert!((v - exact * 2.0).abs() < 1e-3 * exact, "{v}");}-#[test]- fn free_form_loops_that_cannot_be_followed_are_refused() {+ fn free_form_loops_that_are_not_finite_are_refused() {let plate = rectangle(Vec2::ZERO, Vec2::new(100.0, 60.0));let mut bad = ellipse(Vec2::new(40.0, 30.0), 15.0, 8.0);bad.segs[1] = Seg2::Conic { a: bad.segs[1].start(), apex: Vec2::new(f64::NAN, 0.0), b: bad.segs[1].end(), w: 1.0 };let e = planar_regions_boolean(std::slice::from_ref(&plate), &[Region2 { outer: bad, holes: vec![] }], BoolOp::Cut, 1e-7).unwrap_err();assert!(e.to_string().contains("free-form"), "{e}");- // More fitted arcs than the arrangement's segment budget.- let many: Vec<Region2> = (0..400).map(|i| Region2 { outer: ellipse(Vec2::new(40.0 * i as f64, 0.0), 15.0, 8.0), holes: vec![] }).collect();- assert!(planar_regions_boolean(&[plate], &many, BoolOp::Cut, 1e-7).is_err());- }-- #[test]- fn segment_boxes_hold_what_lies_within_the_tolerance() {- // An arc of radius 10 about the origin from 45° to 135° passes the top of its circle:- // x within ±10/√2, y from 10/√2 to 10, grown by twice the tolerance.- let r = 10.0 * std::f64::consts::FRAC_1_SQRT_2;- let arc = Seg2::Arc { center: Vec2::ZERO, radius: 10.0, start: std::f64::consts::FRAC_PI_4, sweep: std::f64::consts::FRAC_PI_2 };- for s in [arc, arc.reversed()] {- let Aabb2 { min: lo, max: hi } = seg_box(&s, 1e-3).unwrap();- assert!(lo.dist(Vec2::new(-r - 2e-3, r - 2e-3)) < 1e-9 && hi.dist(Vec2::new(r + 2e-3, 10.0 + 2e-3)) < 1e-9, "{lo:?} {hi:?}");- }- let Aabb2 { min: lo, max: hi } = seg_box(&Seg2::Line { a: Vec2::new(3.0, -1.0), b: Vec2::new(-2.0, 4.0) }, 0.5).unwrap();- assert!(lo.dist(Vec2::new(-3.0, -2.0)) < 1e-9 && hi.dist(Vec2::new(4.0, 5.0)) < 1e-9, "{lo:?} {hi:?}");- // A line 3 tolerances above the arc's top meets its box (each is grown by two); one- // 5 tolerances above does not. No box (a free-form segment, a value that is not- // finite) hides nothing.- let level = |y: f64| seg_box(&Seg2::Line { a: Vec2::new(-1.0, y), b: Vec2::new(1.0, y) }, 1e-3);- assert!(boxes_meet(seg_box(&arc, 1e-3), level(10.003)) && !boxes_meet(seg_box(&arc, 1e-3), level(10.005)));- let free = ellipse(Vec2::ZERO, 2.0, 1.0).segs[0];- assert!(seg_box(&free, 1e-3).is_none() && seg_box(&Seg2::Line { a: Vec2::new(f64::NAN, 0.0), b: Vec2::X }, 1e-3).is_none());- assert!(boxes_meet(None, level(500.0)) && box_holds(None, Vec2::new(500.0, 500.0)));}-#[test]fn many_small_cut_outs_far_apart_cut_as_before() {// 400 round holes in a strip: almost every pair of segments is far apart.@@ -1464,54 +460,6 @@ mod planar_tests {let exact = 40_000.0 - 400.0 * std::f64::consts::PI * 1.8 * 1.8;assert!((out[0].area() - exact).abs() < 1e-6, "{}", out[0].area());}-- #[test]- fn analytic_circle_classification_respects_signed_sweeps_and_seams() {- for seam in [0.0, 0.13, std::f64::consts::FRAC_PI_2, -std::f64::consts::FRAC_PI_2] {- for reversed in [false, true] {- let lp = Loop2::circle_from(Vec2::ZERO, 10.0, seam);- let lp = if reversed { lp.reversed() } else { lp };- for p in [Vec2::ZERO, Vec2::new(9.9998, 0.0), Vec2::new(0.0, 9.9998), Vec2::new(0.0, -9.9998)] {- assert!(inside_loop(&lp, p), "{seam} {reversed} {p:?}");- }- for p in [Vec2::new(11.0, 0.0), Vec2::new(0.0, 10.0), Vec2::new(0.0, -10.0)] {- assert!(!inside_loop(&lp, p), "{seam} {reversed} {p:?}");- }- }- }- let half = Loop2 {- segs: vec![- Seg2::Arc { center: Vec2::ZERO, radius: 10.0, start: -std::f64::consts::FRAC_PI_2, sweep: std::f64::consts::PI },- Seg2::Line { a: Vec2::new(0.0, 10.0), b: Vec2::new(0.0, -10.0) },- ],- };- for lp in [half.clone(), half.reversed()] {- assert!(inside_loop(&lp, Vec2::new(5.0, 0.0)));- assert!(!inside_loop(&lp, Vec2::new(-5.0, 0.0)));- assert!(!inside_loop(&lp, Vec2::new(-5.0, -10.0)));- }- // #307: a circle read back as two halves whose centres disagree by a few ulps, split- // at its bottom. A ray grazing that bottom must not count one half's touch only.- let halves = Loop2 {- segs: vec![- Seg2::Arc { center: Vec2::new(0.0, 25.0), radius: 5.0, start: -std::f64::consts::FRAC_PI_2, sweep: std::f64::consts::PI },- Seg2::Arc {- center: Vec2::new(2.9e-15, 25.000000000000004),- radius: 4.99999999999999,- start: std::f64::consts::FRAC_PI_2,- sweep: std::f64::consts::PI,- },- ],- };- for lp in [halves.clone(), halves.reversed()] {- for x in [-30.0, -5.0, -0.1] {- assert!(!inside_loop(&lp, Vec2::new(x, 20.0)), "{x}");- assert!(!inside_loop(&lp, Vec2::new(x, 30.0)), "{x}");- }- assert!(inside_loop(&lp, Vec2::new(0.0, 25.0)));- }- }-/// Loops are closed only within the chaining tolerance. A ray level with one end of such a/// gap slipped through it without a crossing, so a point beside the loop counted as inside:/// a sheet shrunk by a parameter change (sketch solver residuals of 1e-13 mm) lost a bend@@ -1528,11 +476,6 @@ mod planar_tests {Seg2::Line { a: Vec2::new(0.0, 5.0), b: Vec2::new(0.0, 0.0) },],};- for lp in [square.clone(), square.reversed()] {- assert!(!inside_loop(&lp, Vec2::new(-5.0, 5.0)));- assert!(inside_loop(&lp, Vec2::new(5.0, 5.0)));- assert!(!inside_loop(&lp, Vec2::new(15.0, 5.0)));- }// A neighbour with an edge level with the gap joins the square instead of being// dropped as if it lay inside it (which left the outline open: no result at all).let a = Region2 { outer: square, holes: vec![] };@@ -1581,17 +524,8 @@ mod planar_tests {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!((union[0].area() - 120.0).abs() < 1e-6, "{meet}: {}", union[0].area());- // The two edges themselves, either way round.- let (edge, tilted) = (square.outer.segs[0], flush.outer.segs[0]);- assert!(crossings(&edge, &tilted, 1e-7).is_empty() && crossings(&tilted, &edge, 1e-7).is_empty(), "{meet}");}- // Lines further apart than the tolerance at their ends still cross: tilted by 1e-3 rad- // about (7, 0), the edge from (4, 3e-3) to (14, -7e-3) meets the bottom edge at x = 7.- let (edge, steep) = (square.outer.segs[0], Seg2::Line { a: Vec2::new(4.0, 3e-3), b: Vec2::new(14.0, -7e-3) });- let hits = crossings(&edge, &steep, 1e-7);- assert!(hits.len() == 1 && (hits[0].0 - 0.7).abs() < 1e-12 && (hits[0].1 - 0.3).abs() < 1e-12, "{hits:?}");}-#[test]fn tiny_tool_between_circle_and_display_chord_is_not_lost() {let circle = Region2 { outer: Loop2::circle(Vec2::ZERO, 10.0), holes: vec![] };@@ -1624,7 +558,6 @@ mod planar_tests {Region2 { outer: Loop2 { segs: vec![arc, Seg2::Line { a: arc.end(), b: out }, Seg2::Line { a: out, b: arc.start() }] }, holes: vec![] };(plate, cut)}-/// A contact between a line and an arc that touch is one point. The quadratic's two roots/// there are rounding noise: a 1e-12 mm error in the centre's distance from the line moves/// them 2e-6 mm either way along it, and the cut then ran that far along the plate's edge@@ -1657,7 +590,6 @@ mod planar_tests {}}}-/// A 55 x 30 plate whose bottom edge bends up by `slope` over its last 5 mm before the/// corner at (100, 50), and a strip 3 wide below the straight 50 mm, as a sheet's bend zone/// lies against its base: the strip's corners on that edge rounded to the nanometre, as a@@ -1670,7 +602,6 @@ mod planar_tests {let strip = [nm(rot(100.0, 50.0)), rot(100.0, 47.0), rot(150.0, 47.0), nm(rot(150.0, 50.0))];(Region2 { outer: Loop2::polygon(&plate), holes: vec![] }, Region2 { outer: Loop2::polygon(&strip), holes: vec![] })}-/// The bent piece of the plate's edge, a hair from the strip's edge, crosses it short of/// the corner they share: the corners a nanometre apart at most, the crossing up to a/// hundred times that before it at a slope of 1 in 100, a thousand at 1 in 1000. A split@@ -1707,37 +638,6 @@ mod planar_tests {}}}-- /// Touching circles meet at one point on the line of their centres, inside and outside.- #[test]- fn touching_lines_and_arcs_meet_at_one_point() {- let full = |c: Vec2, r: f64| Seg2::Arc { center: c, radius: r, start: 0.3, sweep: std::f64::consts::TAU - 1e-3 };- for k in 0..=360 {- let dir = Vec2::from_angle((k as f64 * 0.25).to_radians());- let c = Vec2::new(151.3, -37.7);- for (r0, r1, d) in [(2.0, 3.0, 5.0), (7.0, 3.0, 4.0), (3.0, 7.0, 4.0), (250.0, 2.0, 248.0)] {- let hits = crossings(&full(c, r0), &full(c + dir * d, r1), 1e-7);- let touch = c + dir * if r1 > r0 && d < r1 { -r0 } else { r0 };- let pts: Vec<Vec2> = hits.iter().map(|(u, _)| full(c, r0).point_at(*u)).collect();- assert!(!pts.is_empty() && pts.iter().all(|p| p.dist(touch) < 1e-9), "{k} {r0} {r1}: {pts:?} vs {touch:?}");- }- // A line touching a circle, the circle's side of it and the far side by rounding.- for r in [2.0, 250.0] {- let foot = c + dir * r;- let line = Seg2::Line { a: foot - dir.perp() * 120.0, b: foot + dir.perp() * 78.0 };- let hits = crossings(&line, &full(c, r), 1e-7);- let pts: Vec<Vec2> = hits.iter().map(|(u, _)| line.point_at(*u)).collect();- assert!(!pts.is_empty() && pts.iter().all(|p| p.dist(foot) < 1e-9), "{k} {r}: {pts:?} vs {foot:?}");- }- }- // Real crossings stay two points: a chord 0.01 mm deep in a 2 mm circle.- let line = Seg2::Line { a: Vec2::new(-5.0, 1.99), b: Vec2::new(5.0, 1.99) };- let hits = crossings(&line, &full(Vec2::ZERO, 2.0), 1e-7);- let half = (4.0f64 - 1.99 * 1.99).sqrt();- assert_eq!(hits.len(), 2);- assert!(hits.iter().all(|(u, _)| (line.point_at(*u).x.abs() - half).abs() < 1e-12), "{hits:?}");- }-#[test]fn planar_region_api_rejects_hostile_values_and_budgets() {let plate = rectangle(Vec2::ZERO, Vec2::new(10.0, 10.0));diff --git a/crates/kernel/src/smlib_sweeps.rs b/crates/kernel/src/smlib_sweeps.rsindex 31b66347b2..2aedd93d8f 100644--- a/crates/kernel/src/smlib_sweeps.rs+++ b/crates/kernel/src/smlib_sweeps.rs@@ -71,7 +71,7 @@ pub(crate) struct Draft {}#[cfg(feature = "smlib")]-pub(crate) use imp::{body_from_record, extrude, loft, loft_rails, loft_to_point, revolve, screw, sphere, sweep, sweep_controlled};+pub(crate) use imp::{body_from_record, curve, extrude, loft, loft_rails, loft_to_point, revolve, screw, sphere, sweep, sweep_controlled};/// The error of an SMLib operation in a build without SMLib.#[cfg(not(feature = "smlib"))]@@ -145,7 +145,7 @@ mod imp {}/// The segment in 3D on `plane`, as SMLib's curve.- fn curve(plane: &Plane, s: &Seg2) -> Result<Curve> {+ pub(crate) fn curve(plane: &Plane, s: &Seg2) -> Result<Curve> {let w = |q: Vec2| p(plane.to_world(q));let n = plane.x.cross(plane.y).normalized().ok_or_else(|| KernelError::Invalid("profile plane".into()))?;let bezier = |pts: &[Vec2], weights: &[f64]| {