SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Offset free-form curves and mixed chains: trim folds, round corners (#2149, #2676, #2761, #3159, #3828) (#4156)
Alexander Puzynia37b7b0bd3e34
diff --git a/crates/engine/src/cmd/sketch_modify.rs b/crates/engine/src/cmd/sketch_modify.rsindex a5d93ed780..7a8458a6ff 100644--- a/crates/engine/src/cmd/sketch_modify.rs+++ b/crates/engine/src/cmd/sketch_modify.rs@@ -1810,6 +1810,11 @@ struct Side {constraints: Vec<String>,association: Option<String>,param: Option<String>,+ /// Set when the offset is not linked to its source: a free-form curve whose plain offset+ /// folds over a tight bend or crosses itself (trimmed), or a chain of curves that+ /// includes free-form ones. Its curves then have no association and no distance to+ /// drive, and this names the source curves they were made from.+ unlinked_sources: Option<Vec<String>>,}/// The signed distances an offset runs at. One side is the distance as given. `symmetric` is the@@ -1846,7 +1851,14 @@ fn offset_side(sk: &mut Sketch, cmd: &str, order: &[(usize, bool)], sources: &[(cons.push(add_c(sk, ConstraintKind::Parallel { a, b })?);}}- return Ok(Side { distance: d, curves: created.curves, constraints: cons, association: Some(created.association), param: None });+ return Ok(Side {+ distance: d,+ curves: created.curves,+ constraints: cons,+ association: Some(created.association),+ param: None,+ unlinked_sources: None,+ });}let pieces: Vec<Piece> =order.iter().map(|(c, f)| offset_piece(sk, *c, *f, d)).collect::<Option<_>>().ok_or_else(|| bad(cmd, "the offset collapses an arc"))?;@@ -1942,7 +1954,7 @@ fn offset_side(sk: &mut Sketch, cmd: &str, order: &[(usize, bool)], sources: &[(sk.offsets.push(solidcraft_sketch::OffsetChain { sources: sources.to_vec(), outputs: outputs.clone(), distance: d, closed, topology: None });sk.refresh_offsets()?;}- Ok(Side { distance: d, curves: outputs, constraints: cons, association: None, param: None })+ Ok(Side { distance: d, curves: outputs, constraints: cons, association: None, param: None, unlinked_sources: None })}/// Numbers remain millimetres for programmatic callers; expressions use design units.@@ -2015,7 +2027,7 @@ fn offset_group(sk: &mut Sketch, ids: &[String], eligible: &std::collections::Haclosed: true,topology: None,});- sides.push(Side { distance: r - nr, curves: outputs, constraints: Vec::new(), association: None, param: None });+ sides.push(Side { distance: r - nr, curves: outputs, constraints: Vec::new(), association: None, param: None, unlinked_sources: None });}return Ok(sides);}@@ -2043,16 +2055,41 @@ fn offset_group(sk: &mut Sketch, ids: &[String], eligible: &std::collections::Ha};let runs = offset_runs(d, symmetric, distance2);if order.iter().any(|(i, _)| sk.shape(*i).is_none()) {- // A smooth free-form entity is offset from exact pieces. Junctions that- // would require trimming/intersecting independent normal offsets are- // refused rather than joined by a guessed average point.- if order.len() != 1 {- return Err(bad(cmd, "offset smooth free-form curves individually; mixed chain junctions are ambiguous"));- }- let (source, forward) = *order.first().ok_or_else(|| bad(cmd, "no curves"))?;+ // A smooth free-form entity is offset from exact pieces. One curve gets a linked+ // offset where its plain offset is smooth and simple; otherwise (a fold or a+ // crossing to trim, or a chain with corners) the offset is the trimmed parallel+ // boundary, rounded at outer corners, and not linked to its source.+ let source_ids = order+ .iter()+ .map(|(i, _)| sk.curves.get(*i).map(|c| c.id.clone()).ok_or_else(|| bad(cmd, "offset source vanished")))+ .collect::<Result<Vec<_>>>()?;+ let unlinked = |sk: &Sketch, dd: f64, curves: &[usize]| Side {+ distance: dd,+ curves: ids_of(sk, curves),+ constraints: Vec::new(),+ association: None,+ param: None,+ unlinked_sources: Some(source_ids.clone()),+ };for dd in runs {- let output = sk.add_freeform_offset(source, forward, dd)?;- sides.push(Side { distance: dd, curves: ids_of(sk, &[output]), constraints: Vec::new(), association: None, param: None });+ let side = match order.as_slice() {+ [(source, forward)] => match sk.offset_freeform(*source, *forward, dd)? {+ solidcraft_sketch::FreeformOffsetOutput::Linked(output) => Side {+ distance: dd,+ curves: ids_of(sk, &[output]),+ constraints: Vec::new(),+ association: None,+ param: None,+ unlinked_sources: None,+ },+ solidcraft_sketch::FreeformOffsetOutput::Unlinked(curves) => unlinked(sk, dd, &curves),+ },+ _ => {+ let curves = sk.offset_freeform_chain(&order, dd)?;+ unlinked(sk, dd, &curves)+ }+ };+ sides.push(side);}return Ok(sides);}@@ -2109,6 +2146,7 @@ fn offset(s: &mut Session, p: &Value) -> Result<Value> {let eligible = sk.curves.iter().map(|c| c.id.clone()).collect::<std::collections::HashSet<_>>();let param = doc.new_model_param(&expression, "mm");let param2 = expression2.as_ref().map(|e| doc.new_model_param(e, "mm"));+ let made: Vec<String> = std::iter::once(param.clone()).chain(param2.clone()).collect();let mut pending = ids.clone();let mut sides = Vec::new();while !pending.is_empty() {@@ -2120,6 +2158,7 @@ fn offset(s: &mut Session, p: &Value) -> Result<Value> {.find(|o| o.owns_output(output)).map(|o| o.sources.iter().map(|(id, _)| id.clone()).collect::<Vec<_>>()).or_else(|| sk.freeform_offsets.iter().find(|o| o.output == *output).map(|o| vec![o.source.clone()]))+ .or_else(|| group.iter().find_map(|side| side.unlinked_sources.clone())).ok_or_else(|| bad(cmd, "offset association is missing"))?;// An offset of infinite lines is infinite lines too (#1359).let infinite = sources.iter().all(|id| sk.curve_index(id).and_then(|c| sk.curves.get(c)).is_some_and(|c| c.infinite));@@ -2134,6 +2173,10 @@ fn offset(s: &mut Session, p: &Value) -> Result<Value> {}}for (index, side) in group.iter_mut().enumerate() {+ // A trimmed offset is not linked to its source: it has no distance to drive.+ if side.unlinked_sources.is_some() {+ continue;+ }let name = if index == 1 { param2.as_ref().unwrap_or(¶m) } else { ¶m };let output = side.curves.first().ok_or_else(|| bad(cmd, "offset produced no curves"))?;side.constraints.push(sk.add_constraint(@@ -2149,6 +2192,11 @@ fn offset(s: &mut Session, p: &Value) -> Result<Value> {}sides.extend(group);}+ // Parameters made for distances that only trimmed (unlinked) offsets used drive nothing.+ let used = |name: &String| sides.iter().any(|side: &Side| side.param.as_ref() == Some(name));+ let param = used(¶m).then_some(param);+ let param2 = param2.filter(|name| used(name));+ doc.params.retain(|p| !made.contains(&p.name) || param.as_ref() == Some(&p.name) || param2.as_ref() == Some(&p.name));Ok((sides, param, param2))})?;let curves: Vec<&String> = sides.iter().flat_map(|side| side.curves.iter()).collect();diff --git a/crates/engine/src/cmd/sketch_modify_tests.rs b/crates/engine/src/cmd/sketch_modify_tests.rsindex 950339bb4a..e841d3489c 100644--- a/crates/engine/src/cmd/sketch_modify_tests.rs+++ b/crates/engine/src/cmd/sketch_modify_tests.rs@@ -2174,3 +2174,160 @@ fn trim_cuts_a_line_at_its_tangent_point_on_a_circle() {assert_eq!(sketch(&s).curves.len(), 3, "{name}: the circle and both lines stay");}}++/// A point midway between an offset output and its source, inside the wall they bound.+fn inside_offset_wall(s: &Session, output: &str) -> Vec2 {+ let sk = sketch(s);+ let index = sk.curve_index(output).unwrap();+ let q = sk.exact_pieces(index)[0].point_at(0.5);+ let source: Vec<_> = (0..sk.curves.len()).filter(|i| *i < index && !sk.freeform_offsets.iter().any(|o| o.output == sk.curves[*i].id)).collect();+ let p = source+ .iter()+ .flat_map(|i| sk.exact_pieces(*i))+ .flat_map(|seg| (0..=2000).map(move |k| seg.point_at(k as f64 / 2000.0)))+ .min_by(|a, b| a.dist(q).total_cmp(&b.dist(q)))+ .unwrap();+ p.lerp(q, 0.5)+}++#[test]+fn freeform_offsets_trim_folds_and_round_chain_corners_into_an_extrudable_wall() {+ // A cookie-cutter outline whose notch near (4.2, 36) bends with a radius of about+ // 0.3 mm: 1.26 mm outwards its plain offset folds over itself there. The offset is+ // trimmed to the parallel boundary (open splines meeting at a corner), unlinked.+ let cookie = json!([+ [0, 0],+ [-1.6, 12.8],+ [-7.4, 23.4],+ [-4.8, 26.6],+ [-8.6, 39],+ [2.8, 41.6],+ [4.2, 36],+ [11.8, 43.2],+ [17.2, 43.2],+ [37.2, 24.6],+ [38.6, 23],+ [35.8, 16.4],+ [35.8, 0],+ [24.2, 0],+ [9.6, 0]+ ]);+ let mut s = new_sketch();+ run(&mut s, "sketch.spline.fit_point", json!({"points": cookie, "periodic": true}));+ let (before, params) = (s.doc.to_json(), s.doc.params.len());+ let out = run(&mut s, "sketch.offset", json!({"curves": ["s1"], "distance": 1.26}));+ let curves = ids(&out["curves"]);+ assert!(!curves.is_empty(), "{out}");+ assert_eq!(out["param"], Value::Null, "a trimmed offset has no distance to drive: {out}");+ assert_eq!(out["sketch"]["dof"], 30, "the offset adds no freedom (only the source's fit points move): {out}");+ assert_eq!(s.doc.params.len(), params, "no orphan distance parameter");+ let sk = sketch(&s);+ assert!(sk.freeform_offsets.is_empty() && !sk.constraints.iter().any(|c| matches!(c.kind, ConstraintKind::OffsetDistance { .. })));+ // The source and its offset bound the inner region and the wall around it.+ let areas = profiles(&s);+ assert_eq!(areas.len(), 2, "{areas:?}");+ let wall = inside_offset_wall(&s, &curves[0]);+ run(&mut s, "edit.undo", json!({}));+ assert_eq!(s.doc.to_json(), before);+ run(&mut s, "edit.redo", json!({}));+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"distance": 10, "profiles": [{"point": [wall.x, wall.y]}]}));+ let volume = body_volumes(&mut s);+ assert_eq!(volume.len(), 1);+ assert!((volume[0] - 10.0 * areas[0]).abs() < 0.01 * volume[0], "{volume:?} for a wall of {} mm²", areas[0]);++ // An outline the way drawing programs save it: cubic Bézier curves with two corners,+ // a joint kinked by a few thousandths of a degree, and a zero-length handle. Each+ // side is the parallel boundary, rounded at outer corners and trimmed at inner ones.+ let svg = r#"<svg width="60mm" height="60mm" viewBox="-15 -15 60 60"><path d="M0,0 C10,-5 20,-5 30,0 C35,10 35,20 30,30 C25.0002,40 10,40 5,35 C4,31 8,20 8,20 C0,15 -5,5 0,0 Z"/></svg>"#;+ for distance in [1.26, -1.26] {+ let mut s = new_sketch();+ run(&mut s, "sketch.insert_svg", json!({"text": svg}));+ let sources = sketch(&s).curves.iter().map(|c| c.id.clone()).collect::<Vec<_>>();+ assert_eq!(sources.len(), 5);+ // Picking every curve of the chain makes one offset, not one per curve.+ let out = run(&mut s, "sketch.offset", json!({"curves": sources, "distance": distance}));+ let curves = ids(&out["curves"]);+ let sk = sketch(&s);+ assert!(+ curves.iter().any(|c| matches!(sk.curves[sk.curve_index(c).unwrap()].kind, CurveKind::Arc { .. })),+ "an outer corner is rounded: {out}"+ );+ assert_eq!(sk.curves.len(), 5 + curves.len());+ let source: Vec<_> = (0..5).flat_map(|i| sk.exact_pieces(i)).collect();+ for c in &curves {+ for seg in sk.exact_pieces(sk.curve_index(c).unwrap()) {+ for k in 0..=8 {+ let p = seg.point_at(k as f64 / 8.0);+ let d = source.iter().flat_map(|s| (0..=2000).map(move |j| s.point_at(j as f64 / 2000.0).dist(p))).fold(f64::INFINITY, f64::min);+ assert!((d - 1.26).abs() < solidcraft_sketch::OFFSET_TOLERANCE, "distance {d} at {p:?}");+ }+ }+ }+ let areas = profiles(&s);+ assert_eq!(areas.len(), 2, "{areas:?}");+ let wall = inside_offset_wall(&s, &curves[0]);+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"distance": 10, "profiles": [{"point": [wall.x, wall.y]}]}));+ let volume = body_volumes(&mut s);+ let ring = areas.iter().copied().fold(f64::INFINITY, f64::min).min((areas[1] - areas[0]).abs());+ assert_eq!(volume.len(), 1);+ assert!(volume[0] > 0.0 && (volume[0] - 10.0 * ring).abs() < 0.02 * volume[0], "{volume:?} against {areas:?}");+ }+}++#[test]+fn freeform_chain_offsets_take_the_straight_pieces_of_the_chain_along() {+ // Outlines mix straight pieces with free-form ones: an SVG path with `L` commands, a+ // text glyph (lines and conics). Picking one curve offsets the whole chain, lines too.+ let distance = 1.26;+ let certified = |s: &Session, curves: &[String]| {+ let sk = sketch(s);+ let offsets: Vec<usize> = curves.iter().map(|c| sk.curve_index(c).unwrap()).collect();+ let source: Vec<_> = (0..sk.curves.len()).filter(|i| !offsets.contains(i)).flat_map(|i| sk.exact_pieces(i)).collect();+ for &c in &offsets {+ for seg in sk.exact_pieces(c) {+ for k in 0..=8 {+ let p = seg.point_at(k as f64 / 8.0);+ let d = source.iter().flat_map(|s| (0..=2000).map(move |j| s.point_at(j as f64 / 2000.0).dist(p))).fold(f64::INFINITY, f64::min);+ assert!((d - distance).abs() < solidcraft_sketch::OFFSET_TOLERANCE, "distance {d} at {p:?}");+ }+ }+ }+ };++ let svg = r#"<svg width="60mm" height="60mm" viewBox="-15 -15 60 60"><path d="M0,0 L30,0 C35,10 35,20 30,30 L0,30 Z"/></svg>"#;+ for d in [distance, -distance] {+ let mut s = new_sketch();+ run(&mut s, "sketch.insert_svg", json!({"text": svg}));+ let sk = sketch(&s);+ let kinds = sk.curves.iter().map(|c| matches!(c.kind, CurveKind::Line { .. })).collect::<Vec<_>>();+ assert_eq!(kinds, [true, false, true, true], "lines and one Bézier curve");+ let line = sk.curves[0].id.clone();+ let out = run(&mut s, "sketch.offset", json!({"curves": [line], "distance": d}));+ let curves = ids(&out["curves"]);+ assert!(!curves.is_empty(), "{out}");+ assert_eq!(sketch(&s).curves.len(), 4 + curves.len());+ certified(&s, &curves);+ let areas = profiles(&s);+ assert_eq!(areas.len(), 2, "{areas:?}");+ let wall = inside_offset_wall(&s, &curves[0]);+ run(&mut s, "sketch.finish", json!({}));+ run(&mut s, "solid.extrude", json!({"distance": 10, "profiles": [{"point": [wall.x, wall.y]}]}));+ assert_eq!(body_volumes(&mut s).len(), 1);+ }++ // The letter D: a straight stem and conic bowls, outside and inside.+ let mut s = new_sketch();+ run(&mut s, "sketch.text", json!({"text": "D", "at": [0, 0], "height": 30}));+ let sk = sketch(&s);+ assert!(+ sk.curves.iter().any(|c| matches!(c.kind, CurveKind::Line { .. }))+ && sk.curves.iter().any(|c| sk.shape(sk.curve_index(&c.id).unwrap()).is_none())+ );+ let line = sk.curves.iter().find(|c| matches!(c.kind, CurveKind::Line { .. })).unwrap().id.clone();+ let out = run(&mut s, "sketch.offset", json!({"curves": [line], "distance": distance}));+ let curves = ids(&out["curves"]);+ assert!(!curves.is_empty(), "{out}");+ certified(&s, &curves);+}diff --git a/crates/sketch/src/freeform_offset.rs b/crates/sketch/src/freeform_offset.rsindex 067686941b..fde3254ae7 100644--- a/crates/sketch/src/freeform_offset.rs+++ b/crates/sketch/src/freeform_offset.rs@@ -8,6 +8,9 @@ use crate::{CurveKind, Sketch, SketchError, fit_beziers_mode};use serde::{Deserialize, Serialize};use solidcraft_geom::{Seg2, Vec2};+mod trim;+pub use trim::FreeformOffsetOutput;+pub const OFFSET_TOLERANCE: f64 = 0.002;const MAX_PIECES: usize = 256;const MAX_ASSOCIATIONS: usize = 128;diff --git a/crates/sketch/src/freeform_offset/trim.rs b/crates/sketch/src/freeform_offset/trim.rsnew file mode 100644index 0000000000..380f7ec710--- /dev/null+++ b/crates/sketch/src/freeform_offset/trim.rs@@ -0,0 +1,1295 @@+//! Offsets of free-form curves and chains that a single linked spline cannot follow.+//!+//! Where the distance is larger than a bend's radius, the plain normal offset turns back+//! on itself and makes a small loop; distant parts of a curve can cross the same way. A+//! chain of curves (an imported SVG outline, say) also has corners. The offset here is the+//! parallel boundary: the plain offset of every piece, joined round each corner by an arc+//! about the corner, keeping only the points that no point of the source is nearer to than+//! the offset distance. The kept arcs meet at the plain offset's own crossings, where they+//! form sharp corners. Each kept run of pieces is fitted with an open spline and certified+//! like a linked offset; a corner's arc is exact. Every pair of fitted spans is proven+//! apart except at the nodes they share. The result is ordinary curves: it is not linked+//! to its source.+use super::{Certificate, H, MAX_OFFSET_WORK, MAX_PIECES, OFFSET_TOLERANCE, Result, bad, certify, normal_point};+use crate::{CurveKind, Sketch, fit_beziers};+use solidcraft_geom::{Seg2, Vec2};++/// Samples of the plain offset used to find its crossings (whole chain).+const MAX_SAMPLES: usize = 32_768;+const MAX_CROSSINGS: usize = 256;+/// Pairs compared while searching for crossings and while proving the result simple.+const MAX_PAIR_WORK: usize = 4_000_000;+/// Source parameter below which a piece of a kept arc is too short to fit on its own.+const SLIVER: f64 = 1e-6;+/// The widest source gap between consecutive chained curves.+const SNAP: f64 = OFFSET_TOLERANCE / 8.0;+/// How far a source end whose parameter speed vanishes (a zero-length Bézier handle) may+/// bulge from the straight line that replaces it. Such an end has infinite curvature and+/// no certifiable normal, so its tail is replaced by its chord; the offset is then that of+/// a source at most `TAIL` from the given one, and fits are certified to what is left.+const TAIL: f64 = OFFSET_TOLERANCE / 4.0;+const FIT_TOLERANCE: f64 = OFFSET_TOLERANCE - TAIL;+/// Joints whose two offset ends are at most this far apart (a kink of a fraction of a+/// degree, common where drawing programs join Bézier curves) are joined directly instead+/// of round a corner arc. The shared node sits midway, so each side's certificate carries+/// half the step.+const KINK: f64 = OFFSET_TOLERANCE * 0.8;++/// What an offset of a free-form curve produced.+#[derive(Clone, Debug, PartialEq)]+pub enum FreeformOffsetOutput {+ /// One spline that follows its source (an associative offset).+ Linked(usize),+ /// Open splines (and corner arcs) meeting where the plain offset's loops were trimmed+ /// away. They are ordinary curves, not linked to the source.+ Unlinked(Vec<usize>),+}++/// One piece of the plain offset.+#[derive(Clone, Debug)]+enum Src {+ /// An exact source piece, offset along its normal.+ Seg(Seg2),+ /// A corner of the source: the offset turns about `at` on a circle of radius `|d|`,+ /// from the displacement `from` through `sweep` radians (backwards at an inner corner,+ /// where trimming removes it again).+ Corner { at: Vec2, from: Vec2, sweep: f64 },+}++fn rotate(v: Vec2, angle: f64) -> Vec2 {+ v * angle.cos() + v.perp() * angle.sin()+}++/// The plain offset of a chain, by a global parameter `u = piece index + local parameter`.+struct Raw {+ pieces: Vec<Src>,+ d: f64,+ closed: bool,+}++impl Raw {+ fn span(&self) -> f64 {+ self.pieces.len() as f64+ }+ fn locate(&self, u: f64) -> Result<(usize, f64)> {+ if !u.is_finite() || self.pieces.is_empty() {+ return Err(bad("offset parameter out of range"));+ }+ let n = self.span();+ let u = if self.closed { u.rem_euclid(n) } else { u.clamp(0.0, n) };+ let i = (u.floor() as usize).min(self.pieces.len() - 1);+ Ok((i, (u - i as f64).clamp(0.0, 1.0)))+ }+ fn piece(&self, i: usize) -> Result<&Src> {+ self.pieces.get(i).ok_or_else(|| bad("offset piece out of range"))+ }+ fn piece_point(&self, i: usize, t: f64) -> Result<Vec2> {+ match self.piece(i)? {+ Src::Seg(seg) => normal_point(seg, t, self.d),+ Src::Corner { at, from, sweep } => Ok(*at + rotate(*from, sweep * t)),+ }+ }+ fn point(&self, u: f64) -> Result<Vec2> {+ let (i, t) = self.locate(u)?;+ self.piece_point(i, t)+ }+ fn source(&self, u: f64) -> Result<Vec2> {+ let (i, t) = self.locate(u)?;+ Ok(match self.piece(i)? {+ Src::Seg(seg) => seg.point_at(t),+ Src::Corner { at, .. } => *at,+ })+ }+ /// Source velocity and signed curvature (`None` on a corner).+ fn local(&self, u: f64) -> Result<Option<(Vec2, f64)>> {+ let (i, t) = self.locate(u)?;+ let Src::Seg(seg) = self.piece(i)? else { return Ok(None) };+ let d = seg.derivatives(t, 2).ok_or_else(|| bad("nonfinite offset derivative"))?;+ let (v, a) = (d.first().copied().unwrap_or_default(), d.get(1).copied().unwrap_or_default());+ let speed = v.len();+ if !(speed > 1e-12) || !speed.is_finite() {+ return Err(bad("offset source has a stationary tangent"));+ }+ Ok(Some((v, v.cross(a) / speed.powi(3))))+ }+ /// Velocity of the plain offset. On a piece it is the source velocity scaled by+ /// `1 - d·k`, negative where the offset runs backwards inside a fold.+ fn velocity(&self, u: f64) -> Result<Vec2> {+ if let Some((v, k)) = self.local(u)? {+ return Ok(v * (1.0 - self.d * k));+ }+ let (i, t) = self.locate(u)?;+ match self.piece(i)? {+ Src::Corner { from, sweep, .. } => Ok(rotate(*from, sweep * t).perp() * *sweep),+ Src::Seg(_) => Err(bad("offset piece changed kind")),+ }+ }+ /// Cyclic (closed) or plain distance between two parameters.+ fn gap(&self, a: f64, b: f64) -> f64 {+ let g = (a - b).abs();+ if self.closed { g.min(self.span() - g) } else { g }+ }++ /// The plain offset of the oriented curves of a chain.+ fn chain(sk: &Sketch, order: &[(usize, bool)], d: f64) -> Result<Self> {+ if order.is_empty() || !d.is_finite() || d.abs() < 1e-9 {+ return Err(bad("invalid offset"));+ }+ let mut segs = Vec::new();+ for (curve, forward) in order {+ // Lines and arcs of the chain come from their analytic form, free-form curves exactly.+ let mut pieces = sk.exact_pieces(*curve);+ if pieces.is_empty() {+ return Err(bad("offset source has a curve with no exact pieces"));+ }+ if !forward {+ pieces.reverse();+ pieces = pieces.into_iter().map(|p| p.reversed()).collect();+ }+ for piece in pieces {+ segs.extend(exact_pieces(piece)?);+ }+ if segs.len() > MAX_PIECES {+ return Err(bad("offset source has too many pieces"));+ }+ }+ // The joints as given, before any stationary tail is replaced.+ let ends: Vec<(Vec2, Vec2)> = segs.iter().map(|s: &Seg2| (s.point_at(0.0), s.point_at(1.0))).collect();+ let segs = segs.into_iter().map(resolve_stationary_ends).collect::<Result<Vec<_>>>()?;+ let (Some(first), Some(last)) = (ends.first(), ends.last()) else {+ return Err(bad("offset source has no pieces"));+ };+ let closed = first.0.dist(last.1) <= SNAP;+ let mut pieces = Vec::with_capacity(segs.len() * 2);+ for (i, seg) in segs.iter().enumerate() {+ pieces.push(Src::Seg(*seg));+ let j = if i + 1 < segs.len() {+ i + 1+ } else if closed {+ 0+ } else {+ continue;+ };+ let (Some(next), Some(joint), Some(next_start)) = (segs.get(j), ends.get(i).map(|e| e.1), ends.get(j).map(|e| e.0)) else { continue };+ if joint.dist(next_start) > SNAP {+ return Err(bad("the offset chain has a gap between consecutive curves"));+ }+ // Replaced tails and any gap are bridged by straight lines through the joints+ // as given, so the chain stays exactly continuous.+ let mut path = vec![seg.point_at(1.0)];+ for p in [joint, next_start, next.point_at(0.0)] {+ if path.last().is_some_and(|q: &Vec2| q.dist(p) > 1e-12) {+ path.push(p);+ }+ }+ let mut previous = *seg;+ for w in path.windows(2) {+ let line = Seg2::Line { a: w[0], b: w[1] };+ pieces.extend(corner(&previous, &line, d)?);+ pieces.push(Src::Seg(line));+ previous = line;+ }+ pieces.extend(corner(&previous, next, d)?);+ }+ Ok(Self { pieces, d, closed })+ }+}++/// Source pieces the certificate understands: arcs become exact rational quadratics of at+/// most a quarter turn each; everything else is kept as it is.+fn exact_pieces(seg: Seg2) -> Result<Vec<Seg2>> {+ match seg {+ Seg2::Arc { center, radius, start, sweep } => {+ if !(radius > 1e-9) || !sweep.is_finite() || !(sweep.abs() > 1e-12) {+ return Err(bad("degenerate arc in offset source"));+ }+ let parts = (sweep.abs() / std::f64::consts::FRAC_PI_2).ceil().max(1.0) as usize;+ let step = sweep / parts as f64;+ Ok((0..parts)+ .map(|k| {+ let a0 = start + step * k as f64;+ let half = step / 2.0;+ Seg2::Conic {+ a: center + Vec2::from_angle(a0) * radius,+ apex: center + Vec2::from_angle(a0 + half) * (radius / half.cos()),+ b: center + Vec2::from_angle(a0 + step) * radius,+ w: half.cos(),+ }+ })+ .collect())+ }+ Seg2::Line { a, b } if a.dist(b) < 1e-12 => Ok(Vec::new()),+ other => Ok(vec![other]),+ }+}++/// A piece whose parameter speed vanishes at an end (a zero-length Bézier handle) has a+/// well-defined tangent there but infinite curvature and no certifiable normal. The longest+/// end tail that bulges at most `TAIL` from its chord is cut off; the chain bridges it with+/// that chord.+fn resolve_stationary_ends(seg: Seg2) -> Result<Seg2> {+ let scale = seg.length();+ if !(scale > 1e-9) || !scale.is_finite() {+ return Err(bad("offset source has a degenerate piece"));+ }+ let mut seg = seg;+ for at_end in [false, true] {+ let end = if at_end { 1.0 } else { 0.0 };+ if seg.derivative(end).len() > 1e-6 * scale {+ continue;+ }+ let at = |eps: f64| if at_end { 1.0 - eps } else { eps };+ // How far the tail of length `eps` strays from its chord (it grows with `eps`).+ let bulge = |eps: f64| {+ let (p, q) = (seg.point_at(at(eps)), seg.point_at(end));+ let chord = q - p;+ (1..32)+ .map(|k| {+ let r = seg.point_at(at(eps * k as f64 / 32.0)) - p;+ let along = (r.dot(chord) / chord.len2().max(1e-300)).clamp(0.0, 1.0);+ (r - chord * along).len()+ })+ .fold(0.0_f64, f64::max)+ };+ let (mut lo, mut hi) = (0.0_f64, 0.25_f64);+ if bulge(hi) <= TAIL {+ lo = hi;+ } else {+ for _ in 0..60 {+ let mid = (lo + hi) / 2.0;+ if bulge(mid) <= TAIL { lo = mid } else { hi = mid }+ }+ }+ let cut = at(lo);+ if !(lo > 0.0) || !(seg.derivative(cut).len() > 1e-6 * scale) {+ return Err(bad("offset source has a stationary end that cannot be resolved"));+ }+ seg = if at_end { seg.split_at(cut).0 } else { seg.split_at(cut).1 };+ }+ Ok(seg)+}++/// The corner between two consecutive source pieces, unless they meet smoothly enough+/// (their offset ends at most `KINK` apart) to be joined directly.+fn corner(a: &Seg2, b: &Seg2, d: f64) -> Result<Option<Src>> {+ let at = a.point_at(1.0);+ let ta = a.derivative(1.0).normalized().ok_or_else(|| bad("offset source has a stationary tangent"))?;+ let tb = b.derivative(0.0).normalized().ok_or_else(|| bad("offset source has a stationary tangent"))?;+ let sweep = ta.cross(tb).atan2(ta.dot(tb));+ if sweep.abs() > std::f64::consts::PI - 1e-6 {+ return Err(bad("the offset source turns back on itself at a joint"));+ }+ let step = d.abs() * 2.0 * (sweep.abs() / 2.0).sin();+ if step <= KINK {+ return Ok(None);+ }+ Ok(Some(Src::Corner { at, from: ta.perp() * d, sweep }))+}++/// Where the trimmed result could not be made, and why.+enum Trim {+ /// The plain offset never crosses itself: trimming has nothing to remove.+ NothingToTrim,+ Failed(crate::SketchError),+}+impl From<crate::SketchError> for Trim {+ fn from(error: crate::SketchError) -> Self {+ Trim::Failed(error)+ }+}++#[derive(Clone, Copy, PartialEq)]+enum End {+ /// An end of an open chain's offset.+ Free,+ /// Where a closed offset without crossings starts and ends.+ Seam,+ Crossing(usize),+}++struct Crossing {+ u: f64,+ w: f64,+ at: Vec2,+}++/// One kept arc: the global parameters it runs between, and what is at its ends.+struct Arc {+ a: f64,+ b: f64,+ start: End,+ end: End,+}++/// One output curve of a kept arc.+enum Out {+ Spline { nodes: Vec<Vec2>, cubics: Vec<[Vec2; 4]> },+ Arc { center: Vec2, start: Vec2, end: Vec2, sweep: f64 },+}++impl Out {+ fn ends(&self) -> (Vec2, Vec2) {+ match self {+ Out::Spline { nodes, .. } => (nodes.first().copied().unwrap_or_default(), nodes.last().copied().unwrap_or_default()),+ Out::Arc { start, end, .. } => (*start, *end),+ }+ }+}++/// A fitted kept arc: its curves in order, and what is at its ends.+struct Fitted {+ outs: Vec<Out>,+ start: End,+ end: End,+}++fn segment_crossing(a0: Vec2, a1: Vec2, b0: Vec2, b1: Vec2) -> Option<(f64, f64)> {+ let (r, s) = (a1 - a0, b1 - b0);+ let den = r.cross(s);+ if !(den.abs() > 1e-300) {+ return None;+ }+ let q = b0 - a0;+ let (t, w) = (q.cross(s) / den, q.cross(r) / den);+ ((0.0..=1.0).contains(&t) && (0.0..=1.0).contains(&w)).then_some((t, w))+}++/// Newton on `O(u) = O(w)` from a polyline estimate. Tangential contacts are refused: a+/// trimmed corner is only defined where the two branches really cross.+fn refine_crossing(raw: &Raw, mut u: f64, mut w: f64) -> Result<Crossing> {+ let limit = |x: f64| if raw.closed { x } else { x.clamp(0.0, raw.span()) };+ for _ in 0..50 {+ let (p, q) = (raw.point(u)?, raw.point(w)?);+ let f = p - q;+ let (du, dw) = (raw.velocity(u)?, raw.velocity(w)?);+ // Solve [du, -dw]·[x, y] = -f by Cramer's rule.+ let det = du.cross(dw * -1.0);+ if !(det.abs() > 1e-9 * du.len() * dw.len()) || !det.is_finite() {+ return Err(bad("the offset touches itself tangentially; change the distance slightly"));+ }+ let (x, y) = ((f * -1.0).cross(dw * -1.0) / det, du.cross(f * -1.0) / det);+ u = limit(u + x);+ w = limit(w + y);+ if f.len() <= 1e-12 * (1.0 + p.len()) && x.abs().max(y.abs()) < 1e-13 {+ break;+ }+ }+ let (p, q) = (raw.point(u)?, raw.point(w)?);+ if p.dist(q) > 1e-9 * (1.0 + p.len()) || raw.gap(u, w) < 1e-9 {+ return Err(bad("an offset crossing could not be located exactly"));+ }+ Ok(Crossing { u, w, at: p.lerp(q, 0.5) })+}++/// The same crossing, found twice (either way round).+fn same_crossing(raw: &Raw, a: &Crossing, b: &Crossing) -> bool {+ (raw.gap(a.u, b.u) < 1e-7 && raw.gap(a.w, b.w) < 1e-7) || (raw.gap(a.u, b.w) < 1e-7 && raw.gap(a.w, b.u) < 1e-7)+}++/// Every crossing of the plain offset with itself, from a dense polyline (pruned by chunk+/// bounding boxes) refined by Newton.+fn crossings(raw: &Raw, us: &[f64], pts: &[Vec2]) -> Result<Vec<Crossing>> {+ let segments = pts.len().saturating_sub(1);+ const CHUNK: usize = 8;+ let boxes: Vec<(Vec2, Vec2)> = (0..segments.div_ceil(CHUNK))+ .map(|c| {+ let slice = pts.get(c * CHUNK..((c + 1) * CHUNK + 1).min(pts.len())).unwrap_or(&[]);+ bounds(slice)+ })+ .collect();+ let mut found: Vec<Crossing> = Vec::new();+ let mut work = 0usize;+ for (ca, a) in boxes.iter().enumerate() {+ for (cb, b) in boxes.iter().enumerate().skip(ca) {+ work += 1;+ if work > MAX_PAIR_WORK {+ return Err(bad("offset crossing search work limit exceeded"));+ }+ if a.1.x < b.0.x || b.1.x < a.0.x || a.1.y < b.0.y || b.1.y < a.0.y {+ continue;+ }+ for j in ca * CHUNK..((ca + 1) * CHUNK).min(segments) {+ for k in (cb * CHUNK).max(j + 2)..((cb + 1) * CHUNK).min(segments) {+ if raw.closed && j == 0 && k + 1 == segments {+ continue;+ }+ let (Some(a0), Some(a1), Some(b0), Some(b1)) = (pts.get(j), pts.get(j + 1), pts.get(k), pts.get(k + 1)) else { continue };+ let Some((s, t)) = segment_crossing(*a0, *a1, *b0, *b1) else { continue };+ let (Some(uj), Some(uj1), Some(uk), Some(uk1)) = (us.get(j), us.get(j + 1), us.get(k), us.get(k + 1)) else { continue };+ // Chords either side of a fold's tip, or of a tiny corner arc, can touch+ // without the offset crossing itself there: Newton then collapses onto+ // one point or stalls on a tangential contact. Such a candidate is not+ // a corner to trim at. Skipping a real one is safe: the result is+ // proven free of crossings before it is accepted.+ let crossing = match refine_crossing(raw, uj + (uj1 - uj) * s, uk + (uk1 - uk) * t) {+ Ok(crossing) if raw.gap(crossing.u, crossing.w) >= 1e-4 => crossing,+ _ => continue,+ };+ if !found.iter().any(|c| same_crossing(raw, c, &crossing)) {+ if found.len() >= MAX_CROSSINGS {+ return Err(bad("the offset crosses itself too many times"));+ }+ found.push(crossing);+ }+ }+ }+ }+ }+ // At an inner corner the offsets either side always cross close to it; a small corner's+ // overlap can be far finer than the samples, so it is looked for from the corner itself.+ let n = raw.span();+ for (index, piece) in raw.pieces.iter().enumerate() {+ let Src::Corner { sweep, .. } = piece else { continue };+ if !(raw.d * sweep > 0.0) || (!raw.closed && (index == 0 || index + 1 >= raw.pieces.len())) {+ continue;+ }+ let (before, after) = (index as f64, index as f64 + 1.0);+ let near = |u: f64, w: f64| raw.gap(u, before) < 1.0 && raw.gap(w, after) < 1.0;+ if found.iter().any(|c| near(c.u, c.w) || near(c.w, c.u)) {+ continue;+ }+ for eps in [1e-7, 1e-5, 1e-3, 1e-1] {+ let start = if raw.closed { (before - eps).rem_euclid(n) } else { (before - eps).max(0.0) };+ let Ok(crossing) = refine_crossing(raw, start, after + eps) else { continue };+ let (u, w) = (crossing.u.rem_euclid(n), crossing.w.rem_euclid(n));+ // It must lie on the pieces either side of the corner, not on the corner's arc.+ if raw.gap(u, before) < 1.0 && raw.gap(w, after) < 1.0 && raw.gap(u, before) > 0.0 && raw.gap(w, after) > 0.0 {+ let (Ok((pu, _)), Ok((pw, _))) = (raw.locate(u), raw.locate(w)) else { continue };+ if found.iter().any(|c| same_crossing(raw, c, &crossing)) {+ break;+ }+ if pu != index && pw != index {+ if found.len() >= MAX_CROSSINGS {+ return Err(bad("the offset crosses itself too many times"));+ }+ found.push(crossing);+ break;+ }+ }+ }+ }+ Ok(found)+}++/// Is any point of the source nearer to `q` than `|d|`? The sampled source gives the+/// candidates; Newton on each nearby local minimum gives the exact distance.+fn nearer_than_offset(raw: &Raw, us: &[f64], src: &[Vec2], q: Vec2) -> Result<bool> {+ // A kept point's nearest source point is its own foot, exactly `|d|` away (to rounding);+ // a point inside a small inner corner is nearer by about `|d|·θ²/8`, which for any+ // corner not joined directly is far above this slack.+ let limit = raw.d.abs() * (1.0 - 1e-9) - 1e-12;+ let dist: Vec<f64> = src.iter().map(|p| p.dist(q)).collect();+ if dist.iter().any(|d| *d < limit) {+ return Ok(true);+ }+ let spacing = src.windows(2).map(|w| w[0].dist(w[1])).fold(0.0_f64, f64::max);+ let at = |i: usize| dist.get(i).copied().unwrap_or(f64::INFINITY);+ // A corner's samples all stand for its one point, already measured exactly above; only+ // samples on source pieces (a piece's first sample included) are refined.+ let on_piece = |i: usize| us.get(i).and_then(|u| raw.locate(*u).ok()).is_some_and(|(p, _)| matches!(raw.pieces.get(p), Some(Src::Seg(_))));+ let mut candidates: Vec<usize> = (0..dist.len())+ .filter(|i| {+ let before = if *i == 0 { f64::INFINITY } else { at(i - 1) };+ on_piece(*i) && at(*i) <= before && at(*i) <= at(i + 1) && at(*i) < raw.d.abs() + spacing+ })+ .collect();+ candidates.sort_by(|a, b| at(*a).total_cmp(&at(*b)));+ candidates.truncate(64);+ for i in candidates {+ let Some(&u0) = us.get(i) else { continue };+ let (piece, t0) = raw.locate(u0)?;+ // A sample on a piece boundary is also the end of the previous piece.+ let mut starts = vec![(piece, t0)];+ if t0 == 0.0 {+ if piece > 0 {+ starts.push((piece - 1, 1.0));+ } else if raw.closed {+ starts.push((raw.pieces.len() - 1, 1.0));+ }+ }+ for (piece, mut t) in starts {+ // A corner's source is its single point, already sampled exactly.+ let Some(Src::Seg(seg)) = raw.pieces.get(piece) else { continue };+ for _ in 0..40 {+ let d = seg.derivatives(t, 2).ok_or_else(|| bad("nonfinite offset derivative"))?;+ let (v, a) = (d.first().copied().unwrap_or_default(), d.get(1).copied().unwrap_or_default());+ let h = seg.point_at(t) - q;+ let (f, df) = (h.dot(v), v.dot(v) + h.dot(a));+ if !(df.abs() > 1e-300) {+ break;+ }+ let next = (t - f / df).clamp(0.0, 1.0);+ if (next - t).abs() < 1e-15 {+ t = next;+ break;+ }+ t = next;+ }+ if seg.point_at(t).dist(q) < limit {+ return Ok(true);+ }+ }+ }+ Ok(false)+}++/// Where to test whether the stretch `a..b` of the plain offset is kept: the middle of its+/// longest stretch on an offset piece (a corner's arc can be a sliver at an inner corner).+fn test_parameter(raw: &Raw, a: f64, b: f64) -> f64 {+ let mut best = ((a + b) / 2.0, f64::NEG_INFINITY);+ let mut u = a;+ let mut guard = 0;+ while u < b && guard <= raw.pieces.len() + 1 {+ guard += 1;+ let next = (u.floor() + 1.0).min(b);+ let on_piece = raw.locate((u + next) / 2.0).is_ok_and(|(i, _)| matches!(raw.pieces.get(i), Some(Src::Seg(_))));+ if on_piece && next - u > best.1 {+ best = ((u + next) / 2.0, next - u);+ }+ u = next;+ }+ best.0+}++/// The kept arcs of the plain offset, between consecutive crossings.+fn kept_arcs(raw: &Raw, crossings: &[Crossing], us: &[f64], src: &[Vec2]) -> Result<Vec<Arc>> {+ let n = raw.span();+ let norm = |u: f64| if raw.closed { u.rem_euclid(n) } else { u };+ let mut cuts: Vec<(f64, End)> =+ crossings.iter().enumerate().flat_map(|(i, c)| [(norm(c.u), End::Crossing(i)), (norm(c.w), End::Crossing(i))]).collect();+ cuts.sort_by(|a, b| a.0.total_cmp(&b.0));+ let mut bounds = Vec::new();+ if raw.closed {+ match cuts.first().copied() {+ None => bounds.push(((0.0, End::Seam), (n, End::Seam))),+ Some(first) => {+ for (i, cut) in cuts.iter().enumerate() {+ let next = cuts.get(i + 1).copied().unwrap_or((first.0 + n, first.1));+ bounds.push((*cut, next));+ }+ }+ }+ } else {+ let mut all = vec![(0.0, End::Free)];+ all.extend(cuts);+ all.push((n, End::Free));+ bounds.extend(all.windows(2).map(|w| (w[0], w[1])));+ }+ let mut arcs = Vec::new();+ for ((a, start), (b, end)) in bounds {+ if b - a < 1e-9 {+ return Err(bad("the offset crosses itself at an ambiguous point; change the distance slightly"));+ }+ if !nearer_than_offset(raw, us, src, raw.point(test_parameter(raw, a, b))?)? {+ arcs.push(Arc { a, b, start, end });+ }+ }+ if arcs.is_empty() {+ return Err(bad("the offset distance leaves nothing on this side of the curve"));+ }+ for i in 0..crossings.len() {+ let ends = arcs.iter().map(|arc| usize::from(arc.start == End::Crossing(i)) + usize::from(arc.end == End::Crossing(i))).sum::<usize>();+ if ends > 2 {+ return Err(bad("the offset crosses itself at an ambiguous point; change the distance slightly"));+ }+ }+ Ok(arcs)+}++/// The plain-offset pieces a kept arc runs over: `(piece, from, to)` in local parameters.+fn arc_pieces(raw: &Raw, arc: &Arc) -> Result<Vec<(usize, f64, f64)>> {+ let mut out = Vec::new();+ let mut u = arc.a;+ while u < arc.b - 1e-12 {+ if out.len() > raw.pieces.len() + 1 {+ return Err(bad("offset arc walk did not terminate"));+ }+ let base = u.floor();+ let next = (base + 1.0).min(arc.b);+ let piece = (base as i64).rem_euclid(raw.pieces.len() as i64) as usize;+ out.push((piece, u - base, next - base));+ u = next;+ }+ // A sliver of a piece at either end is covered by its neighbour's span when both are+ // offset pieces; its end node is still placed exactly on the crossing.+ let seg = |p: Option<&(usize, f64, f64)>| p.is_some_and(|p| matches!(raw.pieces.get(p.0), Some(Src::Seg(_))));+ if out.len() > 1 && out.first().is_some_and(|p| p.2 - p.1 < SLIVER) && seg(out.first()) && seg(out.get(1)) {+ out.remove(0);+ }+ let len = out.len();+ if len > 1 && out.last().is_some_and(|p| p.2 - p.1 < SLIVER) && seg(out.last()) && seg(out.get(len - 2)) {+ out.pop();+ }+ if out.is_empty() || out.iter().any(|p| !(p.2 > p.1)) {+ return Err(bad("offset arc is too short to fit"));+ }+ Ok(out)+}++/// Fit and certify one run of offset pieces. It starts from a few uniform spans per piece+/// and halves only the spans whose certificate fails, refitting until every span passes:+/// sharp bends (a fold's neighbourhood, a set-aside tail) get dense nodes, the rest stays+/// sparse. `first` and `last` are its exact end nodes.+fn fit_run(raw: &Raw, run: &[(usize, f64, f64)], first: Vec2, last: Vec2, work: &mut usize) -> Result<Out> {+ let segs = run+ .iter()+ .map(|(i, _, _)| match raw.piece(*i)? {+ Src::Seg(seg) => Ok(*seg),+ Src::Corner { .. } => Err(bad("offset run changed kind")),+ })+ .collect::<Result<Vec<_>>>()?;+ let homogeneous = segs.iter().map(H::from_seg).collect::<Result<Vec<_>>>()?;+ // Spans as (piece of the run, from, to) in that piece's parameter.+ let mut spans: Vec<(usize, f64, f64)> = run+ .iter()+ .enumerate()+ .flat_map(|(k, (_, from, to))| (0..2).map(move |j| (k, from + (to - from) * j as f64 / 2.0, from + (to - from) * (j + 1) as f64 / 2.0)))+ .collect();+ let mut failure = bad("offset arc could not be fitted");+ for _ in 0..32 {+ if spans.len() + 1 >= crate::MAX_SPLINE_POINTS {+ return Err(bad(&format!("the offset needs too many spline nodes to stay within {OFFSET_TOLERANCE} mm: {failure}")));+ }+ let mut nodes = vec![first];+ let mut ranges = Vec::with_capacity(spans.len());+ for (index, (k, a, b)) in spans.iter().enumerate() {+ let (Some(h), Some(seg)) = (homogeneous.get(*k), segs.get(*k)) else { return Err(bad("offset span out of range")) };+ ranges.push(h.range(*a, *b));+ let mut node = normal_point(seg, *b, raw.d)?;+ // A joint joined directly: the node sits midway between the two pieces' ends.+ if let Some((next, start_at, _)) = spans.get(index + 1)+ && next != k+ && let Some(following) = segs.get(*next)+ {+ node = node.lerp(normal_point(following, *start_at, raw.d)?, 0.5);+ }+ nodes.push(node);+ }+ if let Some(end) = nodes.last_mut() {+ *end = last;+ }+ let cubics = fit_beziers(&nodes);+ if cubics.len() != ranges.len() {+ return Err(bad("offset arc fit has a mismatched span count"));+ }+ let mut failing = Vec::new();+ let mut near = first;+ for (index, (h, c)) in ranges.iter().zip(&cubics).enumerate() {+ // Each span's certificate stands on its own; either correspondence proves it.+ let proven = [false, true].into_iter().any(|align_midpoints| {+ match certify(h, c, raw.d, Certificate { tolerance: FIT_TOLERANCE, align_midpoints }, 0, work) {+ Ok(()) => true,+ Err(error) => {+ failure = error;+ false+ }+ }+ });+ if !proven {+ failing.push(index);+ near = c[0];+ }+ if *work == 0 {+ return Err(bad("offset certificate work limit exceeded"));+ }+ }+ if failing.is_empty() {+ return Ok(Out::Spline { nodes, cubics });+ }+ let located = |error: &crate::SketchError| {+ bad(&format!("the offset could not be fitted within {OFFSET_TOLERANCE} mm near ({:.3}, {:.3}): {error}", near.x, near.y))+ };+ let mut refined = Vec::with_capacity(spans.len() + failing.len());+ for (index, (k, a, b)) in spans.iter().copied().enumerate() {+ if failing.binary_search(&index).is_ok() {+ let mid = (a + b) / 2.0;+ if !(mid > a && mid < b) {+ return Err(located(&failure));+ }+ refined.push((k, a, mid));+ refined.push((k, mid, b));+ } else {+ refined.push((k, a, b));+ }+ }+ spans = refined;+ }+ Err(failure)+}++/// Fit one kept arc: a spline for each run of offset pieces, an exact arc for each corner.+fn fit_arc(raw: &Raw, arc: &Arc, crossings: &[Crossing], work: &mut usize) -> Result<Fitted> {+ let pieces = arc_pieces(raw, arc)?;+ let at = |end: End, u: f64| match end {+ End::Crossing(i) => crossings.get(i).map(|c| c.at).ok_or_else(|| bad("offset crossing vanished")),+ End::Free | End::Seam => raw.point(u),+ };+ let (first, last) = (at(arc.start, arc.a)?, at(arc.end, arc.b)?);+ let is_corner = |p: &(usize, f64, f64)| matches!(raw.pieces.get(p.0), Some(Src::Corner { .. }));+ let mut outs = Vec::new();+ let mut start = 0;+ let mut node = first;+ while start < pieces.len() {+ let corner = pieces.get(start).is_some_and(is_corner);+ let mut end = start + 1;+ while end < pieces.len() && !corner && !pieces.get(end).is_some_and(is_corner) {+ end += 1;+ }+ let run = pieces.get(start..end).ok_or_else(|| bad("offset run out of range"))?;+ let (piece, from, to) = run.last().copied().ok_or_else(|| bad("empty offset run"))?;+ // Runs share their boundary node: the start of the following run, which for a+ // corner lies exactly on its arc.+ let next = match pieces.get(end) {+ None => last,+ Some((following, start_at, _)) => raw.piece_point(*following, *start_at)?,+ };+ if corner {+ let Src::Corner { at, sweep, .. } = raw.piece(piece)? else { return Err(bad("offset run changed kind")) };+ outs.push(Out::Arc { center: *at, start: node, end: next, sweep: sweep * (to - from) });+ } else {+ outs.push(fit_run(raw, run, node, next, work)?);+ }+ node = next;+ start = end;+ }+ Ok(Fitted { outs, start: arc.start, end: arc.end })+}++fn bounds(points: &[Vec2]) -> (Vec2, Vec2) {+ let lo = points.iter().fold(Vec2::new(f64::INFINITY, f64::INFINITY), |m, p| Vec2::new(m.x.min(p.x), m.y.min(p.y)));+ let hi = points.iter().fold(Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY), |m, p| Vec2::new(m.x.max(p.x), m.y.max(p.y)));+ (lo, hi)+}++/// A piece of the result for the simplicity proof, with a convex hull that contains it.+#[derive(Clone, Copy)]+enum Prim {+ Cubic([Vec2; 4]),+ /// An arc of at most a quarter turn with its exact (shared) end nodes.+ Arc {+ center: Vec2,+ radius: f64,+ start_angle: f64,+ sweep: f64,+ p0: Vec2,+ p1: Vec2,+ },+}++impl Prim {+ fn hull(&self) -> Vec<Vec2> {+ match *self {+ Prim::Cubic(c) => c.to_vec(),+ Prim::Arc { center, radius, start_angle, sweep, p0, p1 } => {+ // The tangents at the ends meet at the apex; a little slack covers the+ // nodes' rounding off the exact circle.+ let half = sweep / 2.0;+ let apex = center + Vec2::from_angle(start_angle + half) * (radius / half.cos() * (1.0 + 1e-9) + 1e-9);+ vec![p0, apex, p1]+ }+ }+ }+ fn halves(&self) -> (Prim, Prim) {+ match *self {+ Prim::Cubic(c) => {+ let (ab, bc, cd) = (c[0].lerp(c[1], 0.5), c[1].lerp(c[2], 0.5), c[2].lerp(c[3], 0.5));+ let (abc, bcd) = (ab.lerp(bc, 0.5), bc.lerp(cd, 0.5));+ let m = abc.lerp(bcd, 0.5);+ (Prim::Cubic([c[0], ab, abc, m]), Prim::Cubic([m, bcd, cd, c[3]]))+ }+ Prim::Arc { center, radius, start_angle, sweep, p0, p1 } => {+ let half = sweep / 2.0;+ let mid = center + Vec2::from_angle(start_angle + half) * radius;+ (+ Prim::Arc { center, radius, start_angle, sweep: half, p0, p1: mid },+ Prim::Arc { center, radius, start_angle: start_angle + half, sweep: half, p0: mid, p1 },+ )+ }+ }+ }+ fn locally_simple(&self) -> bool {+ match self {+ Prim::Cubic(c) => {+ let chord = c[3] - c[0];+ c.windows(2).all(|p| (p[1] - p[0]).dot(chord) > 1e-18)+ }+ Prim::Arc { sweep, .. } => sweep.abs() <= std::f64::consts::FRAC_PI_2 + 1e-12,+ }+ }+}++/// Do the convex hulls of two pieces meet nowhere except (when given) at the one node+/// they share? Proven by bounding boxes, separating axes, and a separating line through+/// the shared node, subdividing where those are not yet decisive.+fn apart(a: &Prim, b: &Prim, depth: u8, work: &mut usize) -> bool {+ if *work == 0 {+ return false;+ }+ *work -= 1;+ let (ha, hb) = (a.hull(), b.hull());+ let (Some(&a0), Some(&a1), Some(&b0), Some(&b1)) = (ha.first(), ha.last(), hb.first(), hb.last()) else { return false };+ let shared = [a0, a1].into_iter().find(|p| *p == b0 || *p == b1);+ let (la, ua) = bounds(&ha);+ let (lb, ub) = bounds(&hb);+ if shared.is_none() && (ua.x < lb.x || ub.x < la.x || ua.y < lb.y || ub.y < la.y) {+ return true;+ }+ let apart_along = |n: Vec2| {+ let range = |h: &[Vec2]| h.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), p| (lo.min(p.dot(n)), hi.max(p.dot(n))));+ let ((alo, ahi), (blo, bhi)) = (range(&ha), range(&hb));+ ahi < blo || bhi < alo+ };+ match shared {+ None => {+ if [a1 - a0, b1 - b0].iter().any(|d| apart_along(d.perp())) {+ return true;+ }+ }+ Some(x) => {+ let others = |h: &[Vec2]| h.iter().copied().filter(|p| *p != x).collect::<Vec<_>>();+ let (oa, ob) = (others(&ha), others(&hb));+ // Both ends at the shared node means the pieces close a loop on themselves.+ if oa.len() + 1 < ha.len() || ob.len() + 1 < hb.len() || oa.is_empty() || ob.is_empty() {+ return false;+ }+ let leg = |o: &[Vec2]| o.iter().fold(Vec2::ZERO, |s, p| s + (*p - x)).normalized();+ let near = |h: &[Vec2]| {+ let p = if h.first() == Some(&x) { h.get(1) } else { h.len().checked_sub(2).and_then(|i| h.get(i)) };+ p.and_then(|p| (*p - x).normalized())+ };+ let candidates = [leg(&ob).zip(leg(&oa)).map(|(b, a)| b - a), near(&hb).zip(near(&ha)).map(|(b, a)| b - a)];+ let separates = |n: Vec2| {+ n.normalized().is_some_and(|n| {+ let scale = 1e-12 * (1.0 + x.len());+ oa.iter().all(|p| (*p - x).dot(n) < -scale) && ob.iter().all(|p| (*p - x).dot(n) > scale)+ })+ };+ if candidates.into_iter().flatten().any(separates) {+ return true;+ }+ }+ }+ if depth >= 14 {+ return false;+ }+ // Split the larger piece; a half that no longer holds the shared node is compared plainly.+ if (ua - la).len() >= (ub - lb).len() {+ let (a0, a1) = a.halves();+ apart(&a0, b, depth + 1, work) && apart(&a1, b, depth + 1, work)+ } else {+ let (b0, b1) = b.halves();+ apart(a, &b0, depth + 1, work) && apart(a, &b1, depth + 1, work)+ }+}++/// Every piece locally simple, and no two pieces of the result meeting anywhere but at a+/// node they share.+fn verify_trimmed(fitted: &[Fitted]) -> Result<()> {+ let mut prims = Vec::new();+ for out in fitted.iter().flat_map(|f| f.outs.iter()) {+ match out {+ Out::Spline { cubics, .. } => prims.extend(cubics.iter().map(|c| Prim::Cubic(*c))),+ Out::Arc { center, start, end, sweep } => {+ let mut pending = vec![Prim::Arc {+ center: *center,+ radius: center.dist(*start),+ start_angle: (*start - *center).angle(),+ sweep: *sweep,+ p0: *start,+ p1: *end,+ }];+ while let Some(prim) = pending.pop() {+ match prim {+ Prim::Arc { sweep, .. } if sweep.abs() > std::f64::consts::FRAC_PI_4 => {+ let (a, b) = prim.halves();+ pending.push(b);+ pending.push(a);+ }+ _ => prims.push(prim),+ }+ }+ }+ }+ }+ if prims.iter().any(|p| !p.locally_simple()) {+ return Err(bad("trimmed offset spline cannot be certified locally simple"));+ }+ let mut work = MAX_PAIR_WORK;+ for i in 0..prims.len() {+ for j in i + 1..prims.len() {+ let (Some(a), Some(b)) = (prims.get(i), prims.get(j)) else { continue };+ if !apart(a, b, 0, &mut work) {+ return Err(bad(if work == 0 {+ "trimmed offset certificate work limit exceeded"+ } else {+ "trimmed offset self-intersection or ambiguous close contact"+ }));+ }+ }+ }+ Ok(())+}++/// The tightest bend on the offset side (radius and the source point there), if the+/// distance is larger than it.+fn tightest_fold(raw: &Raw, us: &[f64]) -> Option<(f64, Vec2)> {+ let mut worst: Option<(f64, Vec2)> = None;+ for u in us {+ let Ok(Some((_, k))) = raw.local(*u) else { continue };+ if raw.d * k >= 1.0 {+ let radius = 1.0 / k.abs();+ if worst.is_none_or(|(r, _)| radius < r)+ && let Ok(p) = raw.source(*u)+ {+ worst = Some((radius, p));+ }+ }+ }+ worst+}++/// Parameters at which the plain offset is sampled: uniform, refined wherever the offset+/// turns sharply or reverses between two samples, so a small fold (near a zero-length+/// handle, say) is not stepped over.+fn samples(raw: &Raw) -> Vec<f64> {+ let per = (MAX_SAMPLES / 4 / raw.pieces.len().max(1)).clamp(16, 512);+ let mut out = Vec::new();+ let direction = |u: f64| raw.velocity(u).ok().and_then(Vec2::normalized);+ let mut budget = MAX_SAMPLES;+ for j in 0..raw.pieces.len() * per {+ let (a, b) = (j as f64 / per as f64, (j + 1) as f64 / per as f64);+ out.push(a);+ // Depth-first refinement of [a, b], emitting interior samples in order.+ let mut stack = vec![(a, b, 0u8)];+ while let Some((lo, hi, depth)) = stack.pop() {+ let turn = match (direction(lo), direction(hi)) {+ (Some(p), Some(q)) => p.cross(q).atan2(p.dot(q)).abs(),+ _ => f64::INFINITY,+ };+ if turn <= 0.35 || depth >= 16 || budget == 0 {+ if lo > a {+ out.push(lo);+ }+ continue;+ }+ budget -= 1;+ let mid = (lo + hi) / 2.0;+ stack.push((mid, hi, depth + 1));+ stack.push((lo, mid, depth + 1));+ }+ }+ out.push(raw.span());+ out.dedup();+ out+}++/// An error that names the bend the offset folds over, when it does.+fn explain(raw: &Raw, us: &[f64], distance: f64, error: crate::SketchError) -> crate::SketchError {+ match tightest_fold(raw, us) {+ Some((radius, at)) => bad(&format!(+ "the offset distance {:.4} mm is larger than the tightest bend on that side (radius {radius:.4} mm near ({:.3}, {:.3})), and the offset could not be trimmed there: {error}",+ distance.abs(),+ at.x,+ at.y+ )),+ None => error,+ }+}++impl Sketch {+ /// Offset a free-form curve. A curve whose plain offset is smooth and simple gets a+ /// linked offset ([`Sketch::add_freeform_offset`]). Where the plain offset folds over+ /// a bend tighter than the distance, or crosses itself, its loops are trimmed away and+ /// the result is open splines meeting at sharp corners, not linked to the source.+ pub fn offset_freeform(&mut self, source: usize, forward: bool, distance: f64) -> Result<FreeformOffsetOutput> {+ let plain = match self.add_freeform_offset(source, forward, distance) {+ Ok(output) => return Ok(FreeformOffsetOutput::Linked(output)),+ Err(error) => error,+ };+ let Ok(raw) = Raw::chain(self, &[(source, forward)], distance) else {+ return Err(plain);+ };+ let us = samples(&raw);+ match self.add_trimmed_offset(&raw, &us, true) {+ Ok(curves) => Ok(FreeformOffsetOutput::Unlinked(curves)),+ Err(Trim::NothingToTrim) => Err(explain(&raw, &us, distance, plain)),+ Err(Trim::Failed(error)) => Err(explain(&raw, &us, distance, error)),+ }+ }++ /// Offset a chain of curves (oriented, in order) that includes free-form curves: every+ /// piece's normal offset, joined round the chain's corners by arcs and trimmed where it+ /// folds or crosses. The result is ordinary curves, not linked to the chain.+ pub fn offset_freeform_chain(&mut self, order: &[(usize, bool)], distance: f64) -> Result<Vec<usize>> {+ let raw = Raw::chain(self, order, distance)?;+ let us = samples(&raw);+ match self.add_trimmed_offset(&raw, &us, false) {+ Ok(curves) => Ok(curves),+ Err(Trim::NothingToTrim) => Err(bad("offset chain produced nothing")),+ Err(Trim::Failed(error)) => Err(explain(&raw, &us, distance, error)),+ }+ }++ fn add_trimmed_offset(&mut self, raw: &Raw, us: &[f64], require_crossing: bool) -> std::result::Result<Vec<usize>, Trim> {+ let pts = us.iter().map(|u| raw.point(*u)).collect::<Result<Vec<_>>>()?;+ let src = us.iter().map(|u| raw.source(*u)).collect::<Result<Vec<_>>>()?;+ let crossings = crossings(raw, us, &pts)?;+ if crossings.is_empty() && require_crossing {+ return Err(Trim::NothingToTrim);+ }+ let arcs = kept_arcs(raw, &crossings, us, &src)?;+ let mut work = MAX_OFFSET_WORK;+ let fitted = arcs.iter().map(|arc| fit_arc(raw, arc, &crossings, &mut work)).collect::<Result<Vec<_>>>()?;+ verify_trimmed(&fitted)?;+ let mut candidate = self.clone();+ let mut corners: Vec<Option<usize>> = vec![None; crossings.len()];+ let mut outputs = Vec::new();+ for arc in &fitted {+ let mut shared = |end: End, at: Vec2, candidate: &mut Sketch| -> Result<usize> {+ match end {+ End::Crossing(i) => match corners.get(i).copied().flatten() {+ Some(index) => Ok(index),+ None => {+ let index = candidate.add_point(at, None)?;+ if let Some(slot) = corners.get_mut(i) {+ *slot = Some(index);+ }+ Ok(index)+ }+ },+ End::Free | End::Seam => candidate.add_point(at, None),+ }+ };+ let (first_at, _) = arc.outs.first().map(Out::ends).ok_or_else(|| bad("empty offset arc"))?;+ let arc_start = shared(arc.start, first_at, &mut candidate)?;+ let mut node = arc_start;+ let count = arc.outs.len();+ for (k, out) in arc.outs.iter().enumerate() {+ let (_, end_at) = out.ends();+ let end = if k + 1 < count {+ candidate.add_point(end_at, None)?+ } else if arc.end == End::Seam {+ arc_start+ } else {+ shared(arc.end, end_at, &mut candidate)?+ };+ let kind = match out {+ Out::Spline { nodes, .. } => {+ let mut pts = vec![node];+ for p in nodes.iter().skip(1).take(nodes.len().saturating_sub(2)) {+ pts.push(candidate.add_point(*p, None)?);+ }+ pts.push(end);+ CurveKind::Spline { pts, control: false, degree: 3, periodic: false }+ }+ Out::Arc { center, sweep, .. } => {+ let c = candidate.add_point(*center, None)?;+ // Sketch arcs run counter-clockwise from `a` to `b`.+ if *sweep >= 0.0 { CurveKind::Arc { c, a: node, b: end } } else { CurveKind::Arc { c, a: end, b: node } }+ }+ };+ outputs.push(candidate.add_curve(kind, None)?);+ node = end;+ }+ }+ // The result is derived geometry, fixed like a linked offset's nodes: a drag must not+ // bend it away from the certified distance. Its points are its own.+ let made = candidate.points.len();+ for point in candidate.points.iter_mut().skip(self.points.len()).take(made) {+ point.fixed = true;+ }+ *self = candidate;+ Ok(outputs)+ }+}++#[cfg(test)]+#[allow(clippy::unwrap_used, clippy::panic)]+mod tests {+ use super::*;++ fn spline(coords: &[(f64, f64)], periodic: bool) -> (Sketch, usize) {+ let mut sk = Sketch::new();+ let pts = coords.iter().map(|(x, y)| sk.add_point(Vec2::new(*x, *y), None).unwrap()).collect();+ let source = sk.add_curve(CurveKind::Spline { pts, control: false, degree: 3, periodic }, None).unwrap();+ (sk, source)+ }++ /// Distance from `p` to the source by dense sampling (independent of the code under test).+ fn source_distance(segs: &[Seg2], p: Vec2) -> f64 {+ segs.iter().flat_map(|s| (0..=4000).map(move |j| s.point_at(j as f64 / 4000.0).dist(p))).fold(f64::INFINITY, f64::min)+ }++ /// Every output curve stays the offset distance from the source, and (when `closed`)+ /// every output end meets another output's end.+ fn check_offset(sk: &Sketch, source: &[Seg2], curves: &[usize], distance: f64, closed: bool) {+ for c in curves {+ for seg in sk.exact_pieces(*c) {+ for j in 0..=16 {+ let p = seg.point_at(j as f64 / 16.0);+ let found = source_distance(source, p);+ assert!((found - distance).abs() < OFFSET_TOLERANCE, "distance {found} at {p:?}");+ }+ }+ }+ if closed {+ let ends: Vec<Vec2> = curves+ .iter()+ .flat_map(|c| {+ let segs = sk.exact_pieces(*c);+ [segs.first().unwrap().start(), segs.last().unwrap().end()]+ })+ .collect();+ for end in &ends {+ assert!(ends.iter().filter(|e| e.dist(*end) < 1e-9).count() >= 2, "an output end at {end:?} joins nothing");+ }+ }+ }++ /// The cookie-cutter outline from the report: a closed spline whose notch near+ /// (4.2, 36) bends with a radius of about 0.3 mm, offset 1.26 mm outwards.+ const COOKIE: [(f64, f64); 16] = [+ (0.0, 0.0),+ (-1.6, 12.8),+ (-7.4, 23.4),+ (-4.8, 26.6),+ (-8.6, 39.0),+ (2.8, 41.6),+ (4.2, 36.0),+ (11.8, 43.2),+ (17.2, 43.2),+ (37.2, 24.6),+ (38.6, 23.0),+ (35.8, 16.4),+ (35.8, 0.0),+ (24.2, 0.0),+ (9.6, 0.0),+ (0.0, 0.0),+ ];++ #[test]+ fn trimmed_offset_of_closed_spline_with_tight_notch() {+ let (mut sk, source) = spline(&COOKIE, true);+ let before = sk.clone();+ let FreeformOffsetOutput::Unlinked(curves) = sk.offset_freeform(source, true, 1.26).unwrap() else {+ panic!("a 1.26 mm offset over a 0.3 mm notch must be trimmed");+ };+ assert!(sk.freeform_offsets.is_empty(), "a trimmed offset is not linked");+ assert_eq!(&sk.points[..before.points.len()], &before.points);+ let exact = sk.exact_segs(source).unwrap();+ check_offset(&sk, &exact, &curves, 1.26, true);+ // The corner left where the loop was cut lies outside the notch, the full+ // distance from the source.+ let CurveKind::Spline { pts, .. } = &sk.curves[curves[0]].kind else { panic!("spline output") };+ assert!((source_distance(&exact, sk.points[pts[0]].pos) - 1.26).abs() < 1e-6);+ }++ #[test]+ fn untrimmed_offsets_stay_linked_and_inward_is_unchanged() {+ let (mut sk, source) = spline(&COOKIE, true);+ assert!(matches!(sk.offset_freeform(source, true, -1.26).unwrap(), FreeformOffsetOutput::Linked(_)));+ assert_eq!(sk.freeform_offsets.len(), 1);+ }++ #[test]+ fn trimmed_offset_of_open_spline_hairpin() {+ let (mut sk, source) = spline(&[(-25.0, -26.0), (2.6, 3.0), (10.9, 10.7), (-13.9, -3.8)], false);+ let FreeformOffsetOutput::Unlinked(curves) = sk.offset_freeform(source, true, 0.6).unwrap() else {+ panic!("the hairpin offset must be trimmed");+ };+ let exact = sk.exact_segs(source).unwrap();+ check_offset(&sk, &exact, &curves, 0.6, false);+ }++ /// A closed chain of cubic Bézier curves, the way SVG outlines import.+ fn chain_of(beziers: &[[(f64, f64); 4]]) -> (Sketch, Vec<(usize, bool)>) {+ let mut sk = Sketch::new();+ let first = sk.add_point(Vec2::new(beziers[0][0].0, beziers[0][0].1), None).unwrap();+ let mut start = first;+ let mut order = Vec::new();+ for (k, b) in beziers.iter().enumerate() {+ let mid = [1, 2].map(|i| sk.add_point(Vec2::new(b[i].0, b[i].1), None).unwrap());+ let end = if k + 1 == beziers.len() { first } else { sk.add_point(Vec2::new(b[3].0, b[3].1), None).unwrap() };+ let c =+ sk.add_curve(CurveKind::Spline { pts: vec![start, mid[0], mid[1], end], control: true, degree: 3, periodic: false }, None).unwrap();+ order.push((c, true));+ start = end;+ }+ (sk, order)+ }++ /// An outline like an imported SVG: real corners both ways, a joint with a tiny kink,+ /// and a zero-length handle (pointing roughly along its curve, as drawing programs make+ /// them).+ fn bezier_chain() -> (Sketch, Vec<(usize, bool)>) {+ chain_of(&[+ [(0.0, 0.0), (10.0, -5.0), (20.0, -5.0), (30.0, 0.0)],+ // Corner at (30, 0).+ [(30.0, 0.0), (35.0, 10.0), (35.0, 20.0), (30.0, 30.0)],+ // A tiny kink at (30, 30), a few thousandths of a degree off the incoming tangent.+ [(30.0, 30.0), (25.0 + 0.0002, 40.0), (10.0, 40.0), (5.0, 35.0)],+ // A zero-length handle at the end of this piece.+ [(5.0, 35.0), (4.0, 31.0), (8.0, 20.0), (8.0, 20.0)],+ // Corner at (8, 20), then back to the start (a corner there too).+ [(8.0, 20.0), (0.0, 15.0), (-5.0, 5.0), (0.0, 0.0)],+ ])+ }++ #[test]+ fn chain_offset_rounds_outer_corners_and_trims_inner_ones() {+ for distance in [1.26, -1.26] {+ let (mut sk, order) = bezier_chain();+ let before = sk.clone();+ let source: Vec<Seg2> = order.iter().flat_map(|(c, _)| sk.exact_segs(*c).unwrap()).collect();+ let curves = sk.offset_freeform_chain(&order, distance).unwrap();+ assert_eq!(&sk.points[..before.points.len()], &before.points);+ check_offset(&sk, &source, &curves, distance.abs(), true);+ let arcs = curves.iter().filter(|c| matches!(sk.curves[**c].kind, CurveKind::Arc { .. })).count();+ assert!(arcs >= 1, "an outer corner is rounded on each side ({distance})");+ }+ }++ #[test]+ fn sharply_curling_zero_handle_at_a_corner() {+ // A zero-length handle far off its curve's line curls the curve's end sharply+ // (infinite curvature at the end), right before a corner, on both sides.+ let beziers = [+ [(0.0, 0.0), (10.0, -5.0), (20.0, -5.0), (30.0, 0.0)],+ [(30.0, 0.0), (35.0, 10.0), (35.0, 20.0), (30.0, 30.0)],+ [(30.0, 30.0), (25.0, 40.0), (10.0, 40.0), (5.0, 35.0)],+ [(5.0, 35.0), (2.0, 32.0), (8.0, 20.0), (8.0, 20.0)],+ [(8.0, 20.0), (0.0, 15.0), (-5.0, 5.0), (0.0, 0.0)],+ ];+ for distance in [0.5, -0.5, 1.26, -1.26, 3.0, -3.0] {+ let (mut sk, order) = chain_of(&beziers);+ let source: Vec<Seg2> = order.iter().flat_map(|(c, _)| sk.exact_segs(*c).unwrap()).collect();+ let curves = sk.offset_freeform_chain(&order, distance).unwrap();+ check_offset(&sk, &source, &curves, distance.abs(), true);+ }+ }++ #[test]+ fn untrimmable_fold_reports_the_bend() {+ // A single hairpin piece whose offset folds near its open end without crossing back.+ let (mut sk, source) = spline(&[(0.0, 0.0), (10.0, 0.0), (10.2, 0.4)], false);+ let before = sk.clone();+ if let Err(error) = sk.offset_freeform(source, true, 5.0) {+ assert!(error.to_string().contains("bend"), "{error}");+ assert_eq!(sk, before, "a refused offset leaves the sketch unchanged");+ }+ }++ #[test]+ fn hostile_offsets_never_panic() {+ let (sk, source) = spline(&COOKIE, true);+ let (chain, order) = bezier_chain();+ let reversed: Vec<(usize, bool)> = order.iter().rev().map(|(c, f)| (*c, !f)).collect();+ for d in [f64::NAN, f64::INFINITY, 0.0, 1e-12, 1e6, -1e6, 50.0, -50.0, 19.0, 1.26, -1.8, 1.8] {+ for forward in [true, false] {+ let _ = sk.clone().offset_freeform(source, forward, d);+ let _ = chain.clone().offset_freeform_chain(if forward { &order } else { &reversed }, d);+ }+ }+ let _ = chain.clone().offset_freeform_chain(&[], 1.0);+ }+}diff --git a/crates/sketch/src/lib.rs b/crates/sketch/src/lib.rsindex 92599f0978..66ee6b015d 100644--- a/crates/sketch/src/lib.rs+++ b/crates/sketch/src/lib.rs@@ -49,7 +49,7 @@ pub use decompose::Budget;pub use dims::{DimFrame, DimLayout, chain_centres, default_text, dim_frame, dim_layout, dim_layout_reaching, dim_reach, encode_text};pub use ends::{END_TOL, EndReport, EndTouch, UntiedEnd, loose_ends};pub use fonts::{DEFAULT_FONT_FAMILY, FontData, families_in, find_style_in, font_data, font_data_styled, installed_families, set_font_file_check};-pub use freeform_offset::{FreeformOffset, OFFSET_TOLERANCE};+pub use freeform_offset::{FreeformOffset, FreeformOffsetOutput, OFFSET_TOLERANCE};pub use link::{Link, LinkGeom, LinkKind, LinkSource, MAX_LINK_ENTITIES, SKETCH_AXIS_HALF, TextExprs, sketch_axis_geom};pub use model::{Constraint, ConstraintKind, Curve, CurveKind, MAX_CONSTRAINTS, MAX_COORD, MAX_CURVES, MAX_POINTS, PointExprs, SPoint, Sketch, SketchError,