Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

Brushes: bent art keeps its curves (#3926)

bflatastic2d92634371ce
diff --git a/crates/brush/src/tests.rs b/crates/brush/src/tests.rs
index 884dd27cf..28bbcda75 100644
--- a/crates/brush/src/tests.rs
+++ b/crates/brush/src/tests.rs
@@ -27,10 +27,16 @@ fn near(a: f64, b: f64, tol: f64) -> bool {
(a - b).abs() <= tol
}
+/// Points along every outline under `n`, its anchors among them. Bent art keeps its curves and
+/// long lines since #3926, so its anchors alone no longer trace it.
fn all_points(n: &Node, out: &mut Vec<Point>) {
n.walk(&mut |c| {
- if let Some(p) = c.path_data() {
- out.extend(p.anchors().map(|(_, _, a)| a.p));
+ for sp in c.path_data().into_iter().flat_map(|p| &p.subpaths) {
+ out.extend(sp.anchors.iter().map(|a| a.p));
+ for i in 0..sp.segment_count() {
+ let seg = sp.segment(i);
+ out.extend((1..32).map(|j| kurbo::ParamCurve::eval(&seg, j as f64 / 32.0)));
+ }
}
});
}
@@ -185,9 +191,12 @@ fn art_brush_follows_curves() {
}
}
let out = stroke_pieces(&Document::new(1.0, 1.0), &art_brush(rect_art(10.0, 4.0), ArtScale::Stretch), &bp_open, &stroke(1.0));
+ // The long edges bend as curves (#3926), where they used to be cut into some 400 chords. The
+ // path is run along in 0.05 pt chords, which the curves follow, so a few dozen remain.
+ let (anchors, curved) = anchors_and_curved(&out[0]);
+ assert!(anchors < 100 && curved > anchors / 2, "long edges bend as curves: {curved} of {anchors} anchors with handles");
let mut pts = vec![];
all_points(&out[0], &mut pts);
- assert!(pts.len() > 40, "long edges are subdivided so they bend: {}", pts.len());
for p in pts {
let r = p.distance(Point::new(100.0, 100.0));
assert!((r - 100.0).abs() <= 2.0 + 0.3, "point {p:?} is {r} from the centre");
@@ -1226,11 +1235,12 @@ fn a_pattern_tile_keeps_its_curves_on_a_straight_path() {
assert!(near(b.height(), 40.0, 1.0), "and still stand the tile's height: {}", b.height());
}
-/// The other half of the same behaviour: where the path really does bend, the tile is still
-/// subdivided, because an affine cannot reproduce a bend. The fit is checked before it is used,
-/// so a bent run falls back to exactly what it did before.
+/// The other half of the same behaviour: where the path really does bend, an affine cannot
+/// reproduce the bend, so the tile is bent, and it still comes out as curves: cubics fitted to the
+/// bent art rather than the chords it used to be flattened into (#3926). Here a 4-anchor circle
+/// tile runs round a circle of radius 200, so its outline stays in the band 20 either side of it.
#[test]
-fn a_pattern_tile_on_a_bent_path_is_still_subdivided() {
+fn a_pattern_tile_on_a_bent_path_keeps_its_curves() {
let circle =
Node::path(NodeId(0), shapes::ellipse(Rect::new(0.0, -20.0, 40.0, 20.0)), Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 0.0));
let brush = Brush {
@@ -1240,9 +1250,23 @@ fn a_pattern_tile_on_a_bent_path_is_still_subdivided() {
// A circle to run along: every tile sits on a curving section.
let round = shapes::ellipse(Rect::new(0.0, 0.0, 400.0, 400.0)).to_bezpath();
let out = stroke_pieces(&Document::new(1.0, 1.0), &brush, &round, &stroke(1.0));
- assert!(!out.is_empty());
- let bent = out.iter().filter(|n| anchors_and_curved(n).0 > 8).count();
- assert!(bent > out.len() / 2, "tiles on a bend are still densified: {bent} of {}", out.len());
+ assert!(out.len() > 20, "tiles all the way round: {}", out.len());
+ let (mut lo, mut hi) = (f64::MAX, f64::MIN);
+ for n in &out {
+ let (anchors, curved) = anchors_and_curved(n);
+ assert!((4..=16).contains(&anchors), "a bent circle tile is a few curves, not a polygon: {anchors} anchors");
+ assert!(curved == anchors, "every anchor keeps a handle: {curved} of {anchors}");
+ let mut pts = vec![];
+ all_points(n, &mut pts);
+ for q in pts {
+ let r = q.distance(Point::new(200.0, 200.0));
+ (lo, hi) = (lo.min(r), hi.max(r));
+ }
+ }
+ // The path is a cubic circle (0.06 out at most) run along in chords of 0.05, and the fit holds
+ // a quarter of the 0.25 flattening tolerance, so the band holds to 0.2.
+ assert!(lo > 179.8 && hi < 220.2, "the curves stay in the tile's band round the path: {lo:.3}..{hi:.3}");
+ assert!(lo < 180.2 && hi > 219.8, "and reach both edges of it: {lo:.3}..{hi:.3}");
}
/// The kind of every node in a piece of brushed art, in paint order.
diff --git a/crates/brush/src/warp.rs b/crates/brush/src/warp.rs
index 95632ad49..99f7e6304 100644
--- a/crates/brush/src/warp.rs
+++ b/crates/brush/src/warp.rs
@@ -1,13 +1,15 @@
//! Art, scatter and pattern brushes: art bent along the path by arc length.
//!
//! Art coordinates `(x, y)` map to the path point at arc length `s(x)` offset by
-//! `(y - centre) × cross` along the path's left normal. Art outlines are flattened and
-//! subdivided first so long straight edges bend with the path instead of cutting chords.
+//! `(y - centre) × cross` along the path's left normal. Art outlines come out as cubics fitted
+//! to the bent art, so curves stay curves and long straight edges bend with the path (#3926);
+//! where that would take more anchors than chords, they are flattened and subdivided instead.
use std::sync::Arc;
+use kurbo::ParamCurveNearest;
use vectorcraft_doc::{Appearance, Node, NodeId, NodeKind, PressureProfile};
-use vectorcraft_geom::{Affine, BezPath, PathData, PathEl, Point, Rect, SubPath, Vec2};
+use vectorcraft_geom::{Affine, BezPath, CubicBez, ParamCurve, PathData, PathEl, Point, Rect, SubPath, Vec2};
use crate::track::{Rng, Track, normal, seed_of, tracks};
use crate::{ArtBrush, ArtScale, CornerSource, Direction, PatternBrush, PatternFit, Scatter, Variation, tolerance};
@@ -34,22 +36,26 @@ const MAX_WALK: usize = 10_000;
/// Points on each side of the box an Auto-Sliced pattern brush corner masks its tiles with.
const MASK_STEPS: usize = 32;
-/// Bend every path under `n` through `f`. Paths are flattened with `flat_tol` (art space) and
-/// segments subdivided so none is longer than `max_du` along x. Stroke widths scale by
-/// `width_scale`. Text, images and symbol instances can't bend and are dropped.
-pub(crate) fn warp_node(n: &Node, f: &dyn Fn(Point) -> Point, flat_tol: f64, max_du: f64, width_scale: f64) -> Option<Node> {
+/// Bend every path under `n` through `f`. Each art segment comes out as cubics that follow it
+/// through the bend to within [`fit_tol`] of `doc_tol`, the flattening tolerance in document
+/// space, so the art keeps its curves (#3926). Where that cannot be done in no more anchors than
+/// chords would take, the path is flattened with `flat_tol` (art space) and subdivided so no chord
+/// is longer than `max_du` along x, as it always was. Stroke widths scale by `width_scale`.
+/// Text, images and symbol instances can't bend and are dropped.
+pub(crate) fn warp_node(n: &Node, f: &dyn Fn(Point) -> Point, flat_tol: f64, max_du: f64, doc_tol: f64, width_scale: f64) -> Option<Node> {
let mut out = n.clone();
out.appearance.scale_strokes(width_scale);
match &mut out.kind {
NodeKind::Path { path, live, .. } => {
*live = None;
- *path = warp_path(path, f, flat_tol, max_du);
+ *path = warp_path(path, f, flat_tol, max_du, fit_tol(doc_tol));
if path.is_empty() {
return None;
}
}
NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } | NodeKind::Compound { children, .. } => {
- let kids: Vec<Arc<Node>> = children.iter().filter_map(|c| warp_node(c, f, flat_tol, max_du, width_scale)).map(Arc::new).collect();
+ let kids: Vec<Arc<Node>> =
+ children.iter().filter_map(|c| warp_node(c, f, flat_tol, max_du, doc_tol, width_scale)).map(Arc::new).collect();
if kids.is_empty() {
return None;
}
@@ -60,52 +66,154 @@ pub(crate) fn warp_node(n: &Node, f: &dyn Fn(Point) -> Point, flat_tol: f64, max
Some(out)
}
-fn warp_path(p: &PathData, f: &dyn Fn(Point) -> Point, flat_tol: f64, max_du: f64) -> PathData {
- let bp = p.to_bezpath();
+/// Each subpath of `p` through `f`: fitted cubics when they take no more anchors than the chords
+/// would, else the chords. Points `f` cannot place (not finite) are left out of the chords.
+fn warp_path(p: &PathData, f: &dyn Fn(Point) -> Point, flat_tol: f64, max_du: f64, fit_tol: f64) -> PathData {
let mut subs = vec![];
- let mut cur: Vec<Point> = vec![];
- let mut els = vec![];
- kurbo::flatten(bp.iter(), flat_tol.max(1e-4), |e| els.push(e));
- let finish = |cur: &mut Vec<Point>, closed: bool, subs: &mut Vec<SubPath>| {
- let pts = std::mem::take(cur);
- if pts.len() < 2 {
- return;
+ for sp in &p.subpaths {
+ let Some(dense) = densified(sp, flat_tol, max_du) else { continue };
+ if let Some(fit) = fitted(sp, f, fit_tol, dense.len()) {
+ subs.push(fit);
+ continue;
}
- let mut dense = vec![pts[0]];
- let n = pts.len();
- let segs = if closed { n } else { n - 1 };
- for i in 0..segs {
- let (a, b) = (pts[i], pts[(i + 1) % n]);
- let k = (((b.x - a.x).abs() / max_du).ceil() as usize).clamp(1, MAX_SUB);
- for j in 1..=k {
- let q = a.lerp(b, j as f64 / k as f64);
- if closed && i == segs - 1 && j == k {
- break;
- }
- dense.push(q);
- }
+ let mapped: Vec<Point> = dense.into_iter().map(f).filter(|q| q.is_finite()).collect();
+ if mapped.len() >= 2 {
+ subs.push(SubPath::polyline(&mapped, sp.closed));
}
- let mapped: Vec<Point> = dense.into_iter().map(f).collect();
- subs.push(SubPath::polyline(&mapped, closed));
- };
- for e in els {
- match e {
- PathEl::MoveTo(q) => {
- finish(&mut cur, false, &mut subs);
- cur.push(q);
- }
- PathEl::LineTo(q) => cur.push(q),
- PathEl::ClosePath => {
- if cur.len() > 1 && cur[0].distance(cur[cur.len() - 1]) < 1e-9 {
- cur.pop();
- }
- finish(&mut cur, true, &mut subs);
+ }
+ PathData::new(subs)
+}
+
+/// `sp` flattened with `flat_tol` and its chords subdivided so none is longer than `max_du` along
+/// x, in art space: the points the chord route maps. `None` below two points.
+fn densified(sp: &SubPath, flat_tol: f64, max_du: f64) -> Option<Vec<Point>> {
+ let mut bp = BezPath::new();
+ sp.to_bezpath_into(&mut bp);
+ let mut pts = vec![];
+ kurbo::flatten(bp.iter(), flat_tol.max(1e-4), |e| {
+ if let PathEl::MoveTo(q) | PathEl::LineTo(q) = e {
+ pts.push(q);
+ }
+ });
+ if sp.closed && pts.len() > 1 && pts.first()?.distance(*pts.last()?) < 1e-9 {
+ pts.pop();
+ }
+ if pts.len() < 2 {
+ return None;
+ }
+ let segs = if sp.closed { pts.len() } else { pts.len() - 1 };
+ let mut dense = vec![*pts.first()?];
+ for (i, (&a, &b)) in pts.iter().zip(pts.iter().cycle().skip(1)).take(segs).enumerate() {
+ let k = (((b.x - a.x).abs() / max_du).ceil() as usize).clamp(1, MAX_SUB);
+ for j in 1..=k {
+ if sp.closed && i == segs - 1 && j == k {
+ break;
}
- _ => {}
+ dense.push(a.lerp(b, j as f64 / k as f64));
}
}
- finish(&mut cur, false, &mut subs);
- PathData::new(subs)
+ Some(dense)
+}
+
+/// Times an art segment is halved at most while looking for cubics that fit it.
+const FIT_DEPTH: u32 = 12;
+/// Parameter step of the finite differences that stand in for the bend's derivative.
+const FIT_DT: f64 = 1e-6;
+/// Sections a fitted piece is checked at the ends of (the ends themselves are exact).
+const FIT_CHECKS: usize = 8;
+/// Share of the flattening tolerance the fitted curves hold to. The chords were exact at their
+/// points and a few hundredths off between them, so a straight edge bends about as closely.
+const FIT_SHARE: f64 = 0.25;
+/// Tolerance paths are flattened to before art is laid along them.
+const TRACK_TOL: f64 = 0.05;
+
+/// The distance (document space) fitted curves keep to the bent art, for flattening tolerance
+/// `doc_tol`: never below [`TRACK_TOL`], since following the flattened path more closely than it
+/// follows the real one only traces its chords.
+fn fit_tol(doc_tol: f64) -> f64 {
+ (doc_tol * FIT_SHARE).max(TRACK_TOL)
+}
+
+/// `sp` through `f` as cubics within `tol` (document space), one or more per art segment so its
+/// anchors, corners included, stay anchors. `None` when that takes more than `most` anchors, when
+/// a piece still does not fit after [`FIT_DEPTH`] halvings, or when `f` cannot place a point.
+///
+/// Each piece is the cubic with the bent piece's ends and their derivatives, which is the piece
+/// itself where the bend is affine and converges fast where it is not. It is checked against the
+/// bend at the same parameters, so the distance measured is never less than the true one. The
+/// halving is our own rather than kurbo's `fit_to_bezpath`, which halves until the floats run out
+/// on a map that never fits; the depth and the anchor count bound this one.
+fn fitted(sp: &SubPath, f: &dyn Fn(Point) -> Point, tol: f64, most: usize) -> Option<SubPath> {
+ if !(tol.is_finite() && tol > 0.0) {
+ return None;
+ }
+ let start = f(sp.anchors.first()?.p);
+ if !start.is_finite() {
+ return None;
+ }
+ let mut bp = BezPath::new();
+ bp.move_to(start);
+ // Pieces allowed: an open subpath's first anchor is one more, a closed one's last piece ends on it.
+ let mut room = if sp.closed { most } else { most.checked_sub(1)? };
+ for i in 0..sp.segment_count() {
+ let c = sp.segment(i);
+ let line = sp.segment_is_line(i);
+ // A line's handles sit on its ends, which stalls its parameter there; thirds keep it even.
+ let c = if line { CubicBez::new(c.p0, c.p0.lerp(c.p3, 1.0 / 3.0), c.p0.lerp(c.p3, 2.0 / 3.0), c.p3) } else { c };
+ let at = |t: f64| Some(f(c.eval(t))).filter(|q| q.is_finite());
+ fit_into(&at, (0.0, 1.0), line, tol, FIT_DEPTH, &mut bp, &mut room)?;
+ }
+ if sp.closed {
+ bp.close_path();
+ }
+ // The last piece ends on the first anchor's image, so a closed subpath merges it back in; the
+ // count is checked again for a map that jumps right there and keeps the two apart.
+ PathData::from_bezpath(&bp).subpaths.into_iter().next().filter(|s| s.anchors.len() <= most)
+}
+
+/// Pieces for parameters `t0..t1` of the bent segment `at` onto `bp`, which ends at `at(t0)`:
+/// halved until each is within `tol`, at most `depth` times and `room` pieces. A `line` that is
+/// still straight within `tol` stays a line.
+fn fit_into(
+ at: &dyn Fn(f64) -> Option<Point>,
+ (t0, t1): (f64, f64),
+ line: bool,
+ tol: f64,
+ depth: u32,
+ bp: &mut BezPath,
+ room: &mut usize,
+) -> Option<()> {
+ let span = t1 - t0;
+ let (p0, p3) = (at(t0)?, at(t1)?);
+ // Derivatives read from inside the piece, so a kink at either end (a corner, a turn of the
+ // track) stays one.
+ let d0 = (at(t0 + FIT_DT)? - p0) * (span / FIT_DT);
+ let d1 = (p3 - at(t1 - FIT_DT)?) * (span / FIT_DT);
+ let c = CubicBez::new(p0, p0 + d0 / 3.0, p3 - d1 / 3.0, p3);
+ let chord = kurbo::Line::new(p0, p3);
+ let (mut curve_fits, mut line_fits) = (c.is_finite(), line);
+ for k in 1..FIT_CHECKS {
+ if !(curve_fits || line_fits) {
+ break;
+ }
+ let u = k as f64 / FIT_CHECKS as f64;
+ let q = at(t0 + span * u)?;
+ curve_fits &= q.distance(c.eval(u)) <= tol;
+ line_fits &= chord.nearest(q, 1e-9).distance_sq <= tol * tol;
+ }
+ if line_fits || curve_fits {
+ *room = room.checked_sub(1)?;
+ if line_fits {
+ bp.line_to(p3);
+ } else {
+ bp.curve_to(c.p1, c.p2, p3);
+ }
+ return Some(());
+ }
+ let depth = depth.checked_sub(1)?;
+ let mid = t0 + span / 2.0;
+ fit_into(at, (t0, mid), line, tol, depth, bp, room)?;
+ fit_into(at, (mid, t1), line, tol, depth, bp, room)
}
/// Art turned so it runs left → right, flipped as requested; returns it with its bounds.
@@ -281,7 +389,7 @@ fn bend(t: &Track, art: &Node, b: Rect, along: AlongMap, cross: f64) -> Option<N
{
return affine_node(art, a, cross.abs());
}
- warp_node(art, &f, flat_tol, MAX_SEG / along.max_scale(), cross.abs())
+ warp_node(art, &f, flat_tol, MAX_SEG / along.max_scale(), flat_tol * scale, cross.abs())
}
/// [`bend`], with the cross scale at arc length `s` multiplied by `widen(s)` (0..=1). The strokes
@@ -297,7 +405,7 @@ fn bend_widened(t: &Track, art: &Node, b: Rect, along: AlongMap, cross: f64, wid
let art = widen_strokes(art, &factor);
let scale = along.max_scale().max(cross.abs()).max(1e-6);
let flat_tol = tolerance(b.height().max(b.width()) * scale) / scale;
- warp_node(&art, &f, flat_tol, MAX_SEG / along.max_scale(), cross.abs())
+ warp_node(&art, &f, flat_tol, MAX_SEG / along.max_scale(), flat_tol * scale, cross.abs())
}
/// `n` with the strokes of it and of everything inside it scaled by `factor` of the object they
@@ -377,7 +485,7 @@ pub(crate) fn art(a: &ArtBrush, bp: &BezPath, weight: f64, pressure: Option<&Pre
let width = light.max(heavy);
let cross = weight * width / 100.0;
let mut out = vec![];
- for t in tracks(bp, 0.05) {
+ for t in tracks(bp, TRACK_TOL) {
let l = t.len();
if l <= 1e-9 {
continue;
@@ -419,7 +527,7 @@ pub(crate) fn scatter(sc: &Scatter, bp: &BezPath, weight: f64, pressure: Option<
let mut rng = Rng::new(seed_of(bp, name));
let [size_mode, spacing_mode, scatter_mode, rotation_mode] = sc.modes();
let mut out = Budget::default();
- for t in tracks(bp, 0.05) {
+ for t in tracks(bp, TRACK_TOL) {
if out.full() {
break;
}
@@ -588,7 +696,7 @@ fn auto_corner(t: &Track, i: usize, source: CornerSource, side: &(Node, Rect), k
}
let s = if tw > 1e-9 { len / tw } else { 1.0 };
let max_du = MAX_SEG / (2.0 * k * s.max(1.0));
- let warp = |f: &dyn Fn(Point) -> Point| warp_node(art, f, flat_tol, max_du, k);
+ let warp = |f: &dyn Fn(Point) -> Point| warp_node(art, f, flat_tol, max_du, flat_tol * k, k);
// Art point → (distance along from the left edge, stretched to `len`, and offset across).
let along = move |q: Point| {
let (x, y) = local(q);
@@ -686,7 +794,7 @@ pub(crate) fn pattern(pb: &PatternBrush, bp: &BezPath, weight: f64) -> Vec<Node>
let outer_tile = outer.as_ref().map(Corner::Art).or(pb.outer_source.map(Corner::Source));
let inner_tile = inner.as_ref().map(Corner::Art).or(pb.inner_source.map(Corner::Source));
let mut out = Budget::default();
- for t in tracks(bp, 0.05) {
+ for t in tracks(bp, TRACK_TOL) {
if out.full() {
break;
}
@@ -921,4 +1029,108 @@ mod tests {
let moved = bend(&straight, &circle, b, along, cross).expect("the straight run still draws something");
assert_eq!(anchors(&moved), 4, "the straight run keeps the tile's curves");
}
+
+ /// A 4-anchor circle tile filling `b`.
+ fn circle_tile(b: Rect) -> Node {
+ Node::path(
+ NodeId(0),
+ vectorcraft_geom::shapes::ellipse(b),
+ Appearance::basic(vectorcraft_color::Paint::solid(vectorcraft_color::Color::BLACK), vectorcraft_color::Paint::None, 0.0),
+ )
+ }
+
+ /// `per` points along each segment of `sp`, through `f`.
+ fn traced(sp: &SubPath, f: &dyn Fn(Point) -> Point, per: usize) -> Vec<Point> {
+ (0..sp.segment_count())
+ .flat_map(|i| {
+ let c = sp.segment(i);
+ (0..per).map(move |j| f(c.eval(j as f64 / per as f64)))
+ })
+ .collect()
+ }
+
+ /// How far apart two closed outlines get (Hausdorff distance, each taken as a polygon).
+ fn apart(a: &[Point], b: &[Point]) -> f64 {
+ let to = |q: Point, pts: &[Point]| {
+ pts.iter()
+ .zip(pts.iter().cycle().skip(1))
+ .map(|(&a, &b)| {
+ let ab = b - a;
+ let t = ((q - a).dot(ab) / ab.hypot2().max(1e-18)).clamp(0.0, 1.0);
+ q.distance(a + ab * t)
+ })
+ .fold(f64::MAX, f64::min)
+ };
+ let one_way = |a: &[Point], b: &[Point]| a.iter().map(|&q| to(q, b)).fold(0.0, f64::max);
+ one_way(a, b).max(one_way(b, a))
+ }
+
+ /// #3926: on a bend the tile is fitted with cubics instead of flattened into chords. A circle
+ /// tile bent round a circle stays a handful of smooth curves, closer to the bent art than the
+ /// chords were, in a small fraction of their anchors.
+ #[test]
+ fn a_circle_tile_bent_round_a_circle_stays_a_few_curves() {
+ let round = vectorcraft_geom::shapes::ellipse(Rect::new(0.0, 0.0, 400.0, 400.0)).to_bezpath();
+ let t = tracks(&round, 0.05).remove(0);
+ let b = Rect::new(0.0, -20.0, 40.0, 20.0);
+ let along = AlongMap::linear(b.width(), 100.0, 140.0);
+ let tile = circle_tile(b);
+ let NodeKind::Path { path: art, .. } = &tile.kind else { panic!("the tile is a path") };
+ let art = &art.subpaths[0];
+
+ let bent = bend(&t, &tile, b, along, 1.0).expect("the tile is drawn");
+ let NodeKind::Path { path, .. } = &bent.kind else { panic!("a bent path is a path") };
+ assert_eq!(path.subpaths.len(), 1);
+ let sp = &path.subpaths[0];
+ assert!(sp.closed, "still a closed outline");
+ let n = sp.anchors.len();
+ assert!((4..=16).contains(&n), "a few anchors, the tile's own four among them: {n}");
+ assert!(sp.anchors.iter().all(|a| a.has_in() && a.has_out()), "every anchor keeps both handles");
+ assert!(sp.anchors.first().map(|a| a.p) != sp.anchors.last().map(|a| a.p), "closed without a duplicate anchor");
+
+ // The same map `bend` uses, at scale 1, and the tolerance it fits to.
+ let (cy, x0) = (b.center().y, b.x0);
+ let f = |p: Point| t.map(along.at(p.x - x0), p.y - cy);
+ let tol = tolerance(b.height().max(b.width()));
+ let exact = traced(art, &f, 1000);
+ let chords: Vec<Point> = densified(art, tol, MAX_SEG).expect("the tile flattens").into_iter().map(f).collect();
+ let curves = traced(sp, &|p| p, 200);
+ let (e_curves, e_chords) = (apart(&curves, &exact), apart(&chords, &exact));
+ // Checked at eight points a piece, so a little room between them.
+ assert!(e_curves <= fit_tol(tol) * 1.5, "the curves follow the bent art within {}: {e_curves:.4}", fit_tol(tol));
+ assert!(e_curves < e_chords, "closer than the chords were: {e_curves:.4} against {e_chords:.4}");
+ assert!(chords.len() >= 4 * n, "far fewer anchors than the {} chords took: {n}", chords.len());
+ }
+
+ /// Fitting is bounded however badly the map behaves: where it gives points that are not finite
+ /// the tile falls back to chords with those points left out (or to nothing), and where it never
+ /// fits (a map that jumps everywhere) the halving stops at its depth and anchor count. Either
+ /// way the call comes back promptly with finite geometry.
+ #[test]
+ fn a_map_that_misbehaves_still_returns_promptly_and_finite() {
+ let b = Rect::new(0.0, -20.0, 40.0, 20.0);
+ let tile = circle_tile(b);
+ let finite = |n: &Node| match &n.kind {
+ NodeKind::Path { path, .. } => {
+ path.subpaths.iter().flat_map(|s| &s.anchors).all(|a| a.p.is_finite() && a.h_in.is_finite() && a.h_out.is_finite())
+ }
+ _ => false,
+ };
+ let maps: [&dyn Fn(Point) -> Point; 4] = [
+ &|p| if p.x > 25.0 { Point::new(f64::NAN, p.y) } else { p },
+ &|p| if p.y > 10.0 { Point::new(f64::INFINITY, p.y) } else { p + Vec2::new(p.x.sin(), 0.0) },
+ &|p| Point::new(p.x, p.y + if (p.x * 1e3).sin() > 0.0 { 5.0 } else { 0.0 }),
+ &|_| Point::new(f64::NAN, f64::NAN),
+ ];
+ for (i, f) in maps.iter().enumerate() {
+ let t0 = std::time::Instant::now();
+ let out = warp_node(&tile, f, 0.25, 1.5, 0.25, 1.0);
+ assert!(t0.elapsed() < std::time::Duration::from_secs(2), "map {i} took {:?}", t0.elapsed());
+ match (i, &out) {
+ (3, out) => assert!(out.is_none(), "a map that places nothing draws nothing"),
+ (_, Some(n)) => assert!(finite(n), "map {i} drew non-finite geometry"),
+ (_, None) => panic!("map {i} places most points, so something is drawn"),
+ }
+ }
+ }
}