Files
AniCraft/crates/doc/src/width.rs

609 lines
28 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Variable-width strokes (ADR 0018): a stroke's width profile.
//!
//! A profile is a list of width points along each subpath of the stroke: a position `t`
//! (0 at the subpath's start, 1 at its end, by arc length in the shape's own space) and the
//! half-width on each side as a factor of the stroke's nominal half-width (1 = the width set
//! in Properties, so changing the stroke width scales the profile). "Left" is on the left
//! of the direction of travel as seen on the (y-down) stage, in the shape's local space: the
//! side [`left_normal`] points to.
//!
//! Between width points the widths follow a monotone cubic (Fritsch–Carlson), so they are
//! smooth, pass through every point and never overshoot them: a taper never bulges past its
//! ends and never dips below zero. Before the first and after the last point the width holds.
use anicraft_geom::walk::PathWalk;
use anicraft_geom::{Path, Vec2};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
/// Most width points one profile keeps.
pub const MAX_WIDTH_POINTS: usize = 64;
/// Widest a width point may make the stroke, as a factor of its nominal width.
pub const MAX_WIDTH_FACTOR: f32 = 16.0;
/// Width points closer than this (in `t`) are one point.
const MERGE: f32 = 1e-3;
/// A point on a stroke where its width is set.
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct WidthPoint {
/// Position along the subpath, `0..=1` by arc length.
pub t: f32,
/// Half-width on the left side, as a factor of the nominal half-width.
pub left: f32,
/// Half-width on the right side, as a factor of the nominal half-width.
pub right: f32,
}
impl WidthPoint {
pub const fn new(t: f32, left: f32, right: f32) -> WidthPoint {
WidthPoint { t, left, right }
}
fn sanitized(self) -> Option<WidthPoint> {
let f = |v: f32| if v.is_finite() { v.clamp(0.0, MAX_WIDTH_FACTOR) } else { 1.0 };
self.t.is_finite().then(|| WidthPoint { t: self.t.clamp(0.0, 1.0), left: f(self.left), right: f(self.right) })
}
}
/// A stroke's width points: sorted by position, at least one, at most [`MAX_WIDTH_POINTS`],
/// factors in `0..=MAX_WIDTH_FACTOR`, never all 1 (a uniform stroke has no profile).
/// `Arc`-shared, so copying a stroke never copies its points.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(from = "Vec<WidthPoint>", into = "Vec<WidthPoint>")]
pub struct WidthProfile {
points: Arc<[WidthPoint]>,
}
impl From<Vec<WidthPoint>> for WidthProfile {
/// Sanitizes untrusted points (a file, a command). May be uniform: [`Stroke`] drops those.
fn from(v: Vec<WidthPoint>) -> WidthProfile {
let mut pts: Vec<WidthPoint> = v.into_iter().take(MAX_WIDTH_POINTS * 4).filter_map(WidthPoint::sanitized).collect();
pts.sort_by(|a, b| a.t.total_cmp(&b.t));
// Points at (nearly) the same place: the last one given wins.
let mut out: Vec<WidthPoint> = Vec::with_capacity(pts.len());
for p in pts {
match out.last_mut() {
Some(last) if p.t - last.t < MERGE => *last = WidthPoint { t: last.t, ..p },
_ => out.push(p),
}
}
out.truncate(MAX_WIDTH_POINTS);
WidthProfile { points: out.into() }
}
}
impl From<WidthProfile> for Vec<WidthPoint> {
fn from(p: WidthProfile) -> Vec<WidthPoint> {
p.points.to_vec()
}
}
impl WidthProfile {
/// A profile from width points (sanitized); `None` when they make a uniform stroke.
pub fn new(points: Vec<WidthPoint>) -> Option<WidthProfile> {
let p = WidthProfile::from(points);
(!p.is_uniform()).then_some(p)
}
pub fn points(&self) -> &[WidthPoint] {
&self.points
}
/// No points, or every side of every point at the nominal width.
pub fn is_uniform(&self) -> bool {
self.points.iter().all(|p| (p.left - 1.0).abs() < 1e-4 && (p.right - 1.0).abs() < 1e-4)
}
/// The widest either side gets, as a factor of the nominal half-width (the monotone
/// interpolation never exceeds its points).
pub fn max_factor(&self) -> f32 {
self.points.iter().fold(0.0f32, |m, p| m.max(p.left).max(p.right))
}
/// Half-width factors `(left, right)` at `t` along a subpath.
pub fn at(&self, t: f32) -> (f32, f32) {
let t = if t.is_finite() { t.clamp(0.0, 1.0) } else { 0.0 };
(monotone(&self.points, t, |p| p.left), monotone(&self.points, t, |p| p.right))
}
/// The point index at `t` (within the merge distance), if any.
pub fn index_at(&self, t: f32) -> Option<usize> {
self.points.iter().position(|p| (p.t - t).abs() < MERGE)
}
/// With a width point at `t` (replacing one already there); `None` when uniform. Its
/// index in the result is [`WidthProfile::index_at`]`(t)`.
pub fn with_point(&self, p: WidthPoint) -> Option<WidthProfile> {
let mut v: Vec<WidthPoint> = self.points.iter().copied().filter(|q| (q.t - p.t).abs() >= MERGE).collect();
if v.len() >= MAX_WIDTH_POINTS {
return Some(self.clone());
}
v.push(p);
WidthProfile::new(v)
}
/// With point `index` replaced by `p`, kept between its neighbours so the order (and so the
/// indices) stay the same; `None` when uniform, unchanged when there is no such point.
pub fn with_replaced(&self, index: usize, p: WidthPoint) -> Option<WidthProfile> {
let mut v = self.points.to_vec();
let lo = index.checked_sub(1).and_then(|i| v.get(i)).map_or(0.0, |q| q.t + MERGE * 1.5);
let hi = v.get(index + 1).map_or(1.0, |q| q.t - MERGE * 1.5);
let Some(slot) = v.get_mut(index) else { return Some(self.clone()) };
let t = if lo <= hi { p.t.clamp(lo, hi) } else { slot.t };
*slot = WidthPoint { t, ..p };
WidthProfile::new(v)
}
/// Without point `index`; `None` when what is left is uniform.
pub fn without(&self, index: usize) -> Option<WidthProfile> {
let v: Vec<WidthPoint> = self.points.iter().enumerate().filter(|(i, _)| *i != index).map(|(_, p)| *p).collect();
WidthProfile::new(v)
}
/// The profile `t` of the way from `a` to `b` (`None` is uniform). Profiles with the same
/// number of points blend point by point; others blend their widths at every point of
/// either, so any two profiles tween.
pub fn lerp(a: Option<&WidthProfile>, b: Option<&WidthProfile>, t: f32) -> Option<WidthProfile> {
let l = anicraft_geom::lerp;
match (a, b) {
(None, None) => None,
(Some(x), Some(y)) if x.points.len() == y.points.len() => {
WidthProfile::new(x.points.iter().zip(y.points.iter()).map(|(p, q)| WidthPoint::new(l(p.t, q.t, t), l(p.left, q.left, t), l(p.right, q.right, t))).collect())
}
_ => {
let at = |p: Option<&WidthProfile>, s: f32| p.map_or((1.0, 1.0), |p| p.at(s));
let mut ts: Vec<f32> = a.into_iter().chain(b).flat_map(|p| p.points.iter().map(|q| q.t)).collect();
ts.sort_by(f32::total_cmp);
ts.dedup_by(|x, y| (*x - *y).abs() < MERGE);
WidthProfile::new(
ts.into_iter()
.map(|s| {
let ((al, ar), (bl, br)) = (at(a, s), at(b, s));
WidthPoint::new(s, l(al, bl, t), l(ar, br, t))
})
.collect(),
)
}
}
}
/// The built-in profile this one is, if any.
pub fn preset(&self) -> Option<ProfilePreset> {
ProfilePreset::ALL.into_iter().find(|p| p.profile().as_ref() == Some(self))
}
}
/// Fritsch–Carlson monotone cubic through `pts` (sorted by `t`) at `t`, channel `v`.
fn monotone(pts: &[WidthPoint], t: f32, v: impl Fn(&WidthPoint) -> f32) -> f32 {
let (Some(first), Some(last)) = (pts.first(), pts.last()) else { return 1.0 };
if t <= first.t {
return v(first);
}
if t >= last.t {
return v(last);
}
let k = pts.partition_point(|p| p.t <= t).saturating_sub(1);
let (Some(p0), Some(p1)) = (pts.get(k), pts.get(k + 1)) else { return v(last) };
let h = p1.t - p0.t;
if h <= 0.0 {
return v(p1);
}
let slope = |i: usize| -> Option<f32> {
let (a, b) = (pts.get(i)?, pts.get(i + 1)?);
let d = b.t - a.t;
(d > 0.0).then(|| (v(b) - v(a)) / d)
};
// Tangent at point i: zero at a local extremum or where a side is flat, else the harmonic
// mean of the neighbouring slopes (which keeps the curve monotone between points).
let tangent = |i: usize| -> f32 {
let before = i.checked_sub(1).and_then(slope);
let after = slope(i);
match (before, after) {
(Some(a), Some(b)) if a * b > 0.0 => 2.0 * a * b / (a + b),
(Some(_), Some(_)) => 0.0,
(Some(a), None) | (None, Some(a)) => a,
(None, None) => 0.0,
}
};
let (m0, m1) = (tangent(k), tangent(k + 1));
let s = (t - p0.t) / h;
let (s2, s3) = (s * s, s * s * s);
let out = (2.0 * s3 - 3.0 * s2 + 1.0) * v(p0) + (s3 - 2.0 * s2 + s) * h * m0 + (-2.0 * s3 + 3.0 * s2) * v(p1) + (s3 - s2) * h * m1;
// Rounding only: the monotone curve stays between its two points.
out.clamp(v(p0).min(v(p1)), v(p0).max(v(p1)))
}
/// The built-in width profiles offered in Properties and the drawing tools' options.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum ProfilePreset {
#[default]
Uniform,
TaperBoth,
TaperStart,
TaperEnd,
Bulge,
Pinch,
}
impl ProfilePreset {
pub const ALL: [ProfilePreset; 6] = [ProfilePreset::Uniform, ProfilePreset::TaperBoth, ProfilePreset::TaperStart, ProfilePreset::TaperEnd, ProfilePreset::Bulge, ProfilePreset::Pinch];
/// The name used in commands (`taper_both`…).
pub fn key(self) -> &'static str {
match self {
ProfilePreset::Uniform => "uniform",
ProfilePreset::TaperBoth => "taper_both",
ProfilePreset::TaperStart => "taper_start",
ProfilePreset::TaperEnd => "taper_end",
ProfilePreset::Bulge => "bulge",
ProfilePreset::Pinch => "pinch",
}
}
pub fn label(self) -> &'static str {
match self {
ProfilePreset::Uniform => "Uniform",
ProfilePreset::TaperBoth => "Taper both ends",
ProfilePreset::TaperStart => "Taper start",
ProfilePreset::TaperEnd => "Taper end",
ProfilePreset::Bulge => "Bulge",
ProfilePreset::Pinch => "Pinch",
}
}
pub fn from_key(s: &str) -> Option<ProfilePreset> {
let s = s.trim().to_ascii_lowercase().replace([' ', '-'], "_");
ProfilePreset::ALL.into_iter().find(|p| p.key() == s)
}
/// The profile (`None` for Uniform).
pub fn profile(self) -> Option<WidthProfile> {
let p = |t, w| WidthPoint::new(t, w, w);
WidthProfile::new(match self {
ProfilePreset::Uniform => return None,
ProfilePreset::TaperBoth => vec![p(0.0, 0.0), p(0.5, 1.0), p(1.0, 0.0)],
ProfilePreset::TaperStart => vec![p(0.0, 0.0), p(0.4, 1.0), p(1.0, 1.0)],
ProfilePreset::TaperEnd => vec![p(0.0, 1.0), p(0.6, 1.0), p(1.0, 0.0)],
ProfilePreset::Bulge => vec![p(0.0, 0.4), p(0.5, 1.6), p(1.0, 0.4)],
ProfilePreset::Pinch => vec![p(0.0, 1.0), p(0.5, 0.25), p(1.0, 1.0)],
})
}
}
impl WidthProfile {
/// This profile carried onto a piece of its stroke (ADR 0093): the piece runs along the
/// stretches `spans` of `path` (the stroke's path, in path positions: `k + t` is parameter
/// `t` of the segment command `k` draws, as `anicraft_geom::planar::Piece::spans` gives
/// them; a stretch with `to < from` runs backwards). The piece's width at each place is the
/// stroke's width there: every width point inside a stretch moves to the same place on the
/// piece (positions are rescaled by arc length), and where the piece starts, ends or jumps
/// mid-profile, a point there holds the width it had. Running backwards swaps left and
/// right. `None` when the piece has one width.
pub fn along(&self, path: &Path, spans: &[[f64; 2]]) -> Option<WidthProfile> {
let m = Measure::new(path);
let pts = self.points();
let (first, last) = (pts.first().map_or(0.0, |p| p.t), pts.last().map_or(1.0, |p| p.t));
let inside = |f: f32| f > first + MERGE && f < last - MERGE;
// Each stretch: its subpath, and where it starts and ends along it (arc length).
let parts: Vec<(usize, f64, f64)> = spans.iter().take(4096).filter_map(|sp| Some((m.locate(sp[0])?, m.locate(sp[1])?))).filter(|(a, b)| a.0 == b.0).map(|(a, b)| (a.0, a.1, b.1)).collect();
let total: f64 = parts.iter().map(|(_, a, b)| (b - a).abs()).sum();
if !total.is_finite() || total <= 1e-9 {
return Some(self.clone());
}
let mut out: Vec<WidthPoint> = Vec::new();
let mut cum = 0.0f64;
let side = |f: f32, fwd: bool| {
let (l, r) = self.at(f);
if fwd { (l, r) } else { (r, l) }
};
for (i, &(sub, a, b)) in parts.iter().enumerate() {
let len = m.sub_len.get(sub).copied().unwrap_or(0.0);
if !len.is_finite() || len <= 1e-12 {
continue;
}
let (fa, fb) = ((a / len) as f32, (b / len) as f32);
let fwd = b >= a;
let q = |s: f64| ((cum + (s - a).abs()) / total) as f32;
// Joined to the stretch before it without a jump: its points carry on.
let joined_before = i > 0 && parts.get(i - 1).is_some_and(|&(ps, _, pb)| ps == sub && (pb - a).abs() < 1e-6 * len.max(1.0));
let joined_after = parts.get(i + 1).is_some_and(|&(ns, na, _)| ns == sub && (na - b).abs() < 1e-6 * len.max(1.0));
let mark = |s: f64, f: f32, out: &mut Vec<WidthPoint>| {
let (l, r) = side(f, fwd);
out.push(WidthPoint::new(q(s), l, r));
};
// A width point of the stroke's own already sits there.
let has_point = |f: f32| pts.iter().any(|p| (p.t - f).abs() < 1e-6);
if !joined_before && (i > 0 || inside(fa)) && !has_point(fa) {
mark(a, fa, &mut out);
}
let (lo, hi) = (fa.min(fb) - 1e-6, fa.max(fb) + 1e-6);
let within: Vec<&WidthPoint> = pts.iter().filter(|p| p.t >= lo && p.t <= hi).collect();
let ordered: Box<dyn Iterator<Item = &&WidthPoint>> = if fwd { Box::new(within.iter()) } else { Box::new(within.iter().rev()) };
for p in ordered {
let (l, r) = if fwd { (p.left, p.right) } else { (p.right, p.left) };
out.push(WidthPoint::new(q(f64::from(p.t) * len), l, r));
}
if !joined_after && (i + 1 < parts.len() || inside(fb)) && !has_point(fb) {
mark(b, fb, &mut out);
}
cum += (b - a).abs();
}
if out.len() > MAX_WIDTH_POINTS {
// Evenly spaced, the ends kept.
let n = out.len();
let k = MAX_WIDTH_POINTS;
out = (0..k).filter_map(|i| out.get(i * (n - 1) / (k - 1)).copied()).collect();
}
if out.is_empty() {
// No point falls on the piece: it lies where the width holds, one width all along.
let f = parts.first().and_then(|&(sub, a, _)| m.sub_len.get(sub).filter(|l| **l > 1e-12).map(|l| (a / l) as f32)).unwrap_or(0.0);
let fwd = parts.first().is_none_or(|&(_, a, b)| b >= a);
let (l, r) = side(f, fwd);
out.push(WidthPoint::new(0.0, l, r));
}
WidthProfile::new(out)
}
}
/// Arc lengths along a path's subpaths, by path position.
struct Measure {
/// Each drawn command: its index, subpath, arc length where it starts, and its curve.
segs: Vec<(usize, usize, f64, [Vec2; 4])>,
sub_len: Vec<f64>,
}
impl Measure {
fn new(path: &Path) -> Measure {
use anicraft_geom::PathCmd;
let mut segs = Vec::new();
let mut sub_len: Vec<f64> = Vec::new();
let (mut start, mut cur, mut acc) = (Vec2::ZERO, Vec2::ZERO, 0.0f64);
let line = |a: Vec2, b: Vec2| [a, a.lerp(b, 1.0 / 3.0), a.lerp(b, 2.0 / 3.0), b];
for (k, c) in path.cmds.iter().enumerate().take(1 << 20) {
let curve = match *c {
PathCmd::MoveTo(p) => {
if !sub_len.is_empty() || !segs.is_empty() {
sub_len.push(acc);
}
(start, cur, acc) = (p, p, 0.0);
continue;
}
PathCmd::LineTo(p) => line(cur, p),
PathCmd::QuadTo(q, p) => [cur, cur.lerp(q, 2.0 / 3.0), p.lerp(q, 2.0 / 3.0), p],
PathCmd::CubicTo(a, b, p) => [cur, a, b, p],
PathCmd::Close => line(cur, start),
};
segs.push((k, sub_len.len(), acc, curve));
acc += cubic_length(&curve, 1.0);
cur = curve[3];
}
sub_len.push(acc);
Measure { segs, sub_len }
}
/// The subpath and arc length from its start at path position `u`.
fn locate(&self, u: f64) -> Option<(usize, f64)> {
if !u.is_finite() {
return None;
}
let k = u.floor();
let t = u - k;
// Position `k + 1` is the end of command `k`.
let (k, t) = if t == 0.0 && k >= 1.0 && !self.segs.iter().any(|s| s.0 as f64 == k) { (k - 1.0, 1.0) } else { (k, t) };
let i = self.segs.partition_point(|s| (s.0 as f64) < k);
match self.segs.get(i) {
Some(&(cmd, sub, at, c)) if cmd as f64 == k => Some((sub, at + cubic_length(&c, t))),
// The end of the last command (or of one before a MoveTo).
_ => {
let &(_, sub, at, c) = self.segs.get(i.checked_sub(1)?)?;
(t == 0.0).then(|| (sub, at + cubic_length(&c, 1.0)))
}
}
}
}
/// Arc length of a cubic from 0 to `t` (composite five-point Gauss–Legendre on 16 pieces).
fn cubic_length(c: &[Vec2; 4], t: f64) -> f64 {
const G: [(f64, f64); 5] = [(0.046_910_077_030_668, 0.118_463_442_528_094_5), (0.230_765_344_947_158_45, 0.239_314_335_249_683_2), (0.5, 0.284_444_444_444_444_4), (0.769_234_655_052_841_6, 0.239_314_335_249_683_2), (0.953_089_922_969_332, 0.118_463_442_528_094_5)];
let t = t.clamp(0.0, 1.0);
let p = c.map(|v| (f64::from(v.x), f64::from(v.y)));
let speed = |s: f64| {
let u = 1.0 - s;
let (d0, d1, d2) = (3.0 * u * u, 6.0 * u * s, 3.0 * s * s);
let dx = d0 * (p[1].0 - p[0].0) + d1 * (p[2].0 - p[1].0) + d2 * (p[3].0 - p[2].0);
let dy = d0 * (p[1].1 - p[0].1) + d1 * (p[2].1 - p[1].1) + d2 * (p[3].1 - p[2].1);
(dx * dx + dy * dy).sqrt()
};
const N: usize = 16;
let h = t / N as f64;
(0..N).map(|i| G.iter().map(|&(x, w)| w * speed((i as f64 + x) * h)).sum::<f64>() * h).sum()
}
/// The unit normal on the left of direction `d` on a y-down screen (`-d.perp()`).
pub fn left_normal(d: Vec2) -> Vec2 {
Vec2::new(d.y, -d.x)
}
/// A shape's subpaths as walks in its local space (closed ones end where they start), for
/// placing and finding width points. `tolerance` is in local units.
pub fn stroke_walks(path: &Path, tolerance: f32) -> Vec<PathWalk> {
path.flatten(&anicraft_geom::Affine::IDENTITY, tolerance)
.into_iter()
.take(4096)
.filter_map(|line| {
let mut pts = line.points;
if line.closed
&& let Some(&first) = pts.first()
{
pts.push(first);
}
PathWalk::new(&pts)
})
.collect()
}
/// Where a stroke passes nearest to `p` (local space): `(subpath, t, distance, side)`, `side`
/// being `1.0` on the left of the direction of travel and `-1.0` on the right.
pub fn nearest_on_stroke(walks: &[PathWalk], p: Vec2) -> Option<(usize, f32, f32, f32)> {
let mut best: Option<(usize, f32, f32, f32)> = None;
for (i, w) in walks.iter().enumerate() {
let s = w.project(p);
let q = w.at(s);
let d = q.distance(p);
if best.is_none_or(|b| d < b.2) {
let side = if (p - q).dot(left_normal(w.tangent(s))) >= 0.0 { 1.0 } else { -1.0 };
let len = w.length();
best = Some((i, if len > 0.0 { s / len } else { 0.0 }, d, side));
}
}
best
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn profiles_are_sanitized_and_uniform_ones_dropped() {
let p = WidthProfile::from(vec![WidthPoint::new(0.9, 2.0, 2.0), WidthPoint::new(f32::NAN, 0.0, 0.0), WidthPoint::new(-3.0, -1.0, 99.0), WidthPoint::new(0.9002, 3.0, 3.0)]);
assert_eq!(p.points(), &[WidthPoint::new(0.0, 0.0, MAX_WIDTH_FACTOR), WidthPoint::new(0.9, 3.0, 3.0)]);
assert!(WidthProfile::new(vec![WidthPoint::new(0.3, 1.0, 1.0)]).is_none(), "all nominal: uniform");
assert!(WidthProfile::new(vec![]).is_none());
let many: Vec<WidthPoint> = (0..1000).map(|i| WidthPoint::new(i as f32 / 1000.0, 2.0, 2.0)).collect();
assert_eq!(WidthProfile::from(many).points().len(), MAX_WIDTH_POINTS);
}
#[test]
fn widths_pass_through_points_smoothly_without_overshoot() {
let p = ProfilePreset::TaperBoth.profile().unwrap();
assert_eq!(p.at(0.0), (0.0, 0.0));
assert_eq!(p.at(0.5), (1.0, 1.0));
assert_eq!(p.at(1.0), (0.0, 0.0));
// Symmetric, rising then falling, never above the peak.
let (a, _) = p.at(0.25);
let (b, _) = p.at(0.75);
assert!((a - b).abs() < 1e-5 && a > 0.3 && a < 1.0, "{a} {b}");
let mut last = -1.0;
for i in 0..=50 {
let (w, _) = p.at(i as f32 / 100.0);
assert!(w >= last - 1e-6 && w <= 1.0);
last = w;
}
// Flat at the peak: the tangent there is zero.
assert!(p.at(0.49).0 > 0.999);
// Holds outside the points; garbage positions are safe.
let q = WidthProfile::new(vec![WidthPoint::new(0.25, 2.0, 0.5), WidthPoint::new(0.75, 0.5, 2.0)]).unwrap();
assert_eq!(q.at(0.0), (2.0, 0.5));
assert_eq!(q.at(1.0), (0.5, 2.0));
assert_eq!(q.at(f32::NAN), (2.0, 0.5));
assert_eq!(q.max_factor(), 2.0);
}
#[test]
fn editing_points_keeps_order_and_falls_back_to_uniform() {
let p = ProfilePreset::TaperBoth.profile().unwrap();
let q = p.with_point(WidthPoint::new(0.25, 3.0, 3.0)).unwrap();
assert_eq!(q.index_at(0.25), Some(1));
assert_eq!(q.points().len(), 4);
// Moving a point stays between its neighbours.
let r = q.with_replaced(1, WidthPoint::new(0.9, 3.0, 1.0)).unwrap();
assert!(r.points()[1].t < 0.5 && r.points()[1].t > 0.25);
assert_eq!(q.with_replaced(9, WidthPoint::new(0.5, 1.0, 1.0)), Some(q.clone()), "no such point: unchanged");
let one = WidthProfile::new(vec![WidthPoint::new(0.5, 2.0, 2.0)]).unwrap();
assert!(one.without(0).is_none(), "nothing left: uniform");
assert_eq!(p.preset(), Some(ProfilePreset::TaperBoth));
assert_eq!(q.preset(), None);
assert_eq!(ProfilePreset::from_key("Taper Both"), Some(ProfilePreset::TaperBoth));
assert!(ProfilePreset::Uniform.profile().is_none());
}
#[test]
fn profiles_tween_pointwise_or_by_resampling() {
let a = ProfilePreset::TaperBoth.profile().unwrap();
let b = ProfilePreset::Bulge.profile().unwrap();
let mid = WidthProfile::lerp(Some(&a), Some(&b), 0.5).unwrap();
assert_eq!(mid.points().len(), 3);
assert!((mid.at(0.0).0 - 0.2).abs() < 1e-5 && (mid.at(0.5).0 - 1.3).abs() < 1e-5);
// Different point counts, and to or from uniform: widths blend everywhere.
let c = WidthProfile::new(vec![WidthPoint::new(0.2, 2.0, 2.0), WidthPoint::new(0.8, 0.5, 0.5)]).unwrap();
let m2 = WidthProfile::lerp(Some(&a), Some(&c), 0.5).unwrap();
assert_eq!(m2.points().len(), 5);
for s in [0.0, 0.2, 0.5, 0.8, 1.0] {
let want = (a.at(s).0 + c.at(s).0) * 0.5;
assert!((m2.at(s).0 - want).abs() < 1e-4, "{s}");
}
let half = WidthProfile::lerp(Some(&a), None, 0.5).unwrap();
assert!((half.at(0.0).0 - 0.5).abs() < 1e-5);
assert!(WidthProfile::lerp(Some(&a), None, 1.0).is_none(), "all the way to uniform");
assert!(WidthProfile::lerp(None, None, 0.3).is_none());
}
#[test]
fn finds_the_nearest_place_on_a_stroke() {
let mut path = Path::new();
path.move_to(Vec2::new(0.0, 0.0)).line_to(Vec2::new(100.0, 0.0));
let walks = stroke_walks(&path, 0.25);
let (sub, t, d, side) = nearest_on_stroke(&walks, Vec2::new(25.0, -4.0)).unwrap();
assert_eq!(sub, 0);
assert!((t - 0.25).abs() < 1e-5 && (d - 4.0).abs() < 1e-5);
assert_eq!(side, 1.0, "heading right on a y-down screen, up (-y) is on the left");
assert_eq!(nearest_on_stroke(&walks, Vec2::new(25.0, 4.0)).unwrap().3, -1.0);
// A closed square walks back to its start.
let sq = stroke_walks(&Path::rect(0.0, 0.0, 10.0, 10.0), 0.25);
assert_eq!(sq[0].length(), 40.0);
assert!(nearest_on_stroke(&[], Vec2::ZERO).is_none());
}
fn near(a: (f32, f32), b: (f32, f32), tol: f32) -> bool {
(a.0 - b.0).abs() <= tol && (a.1 - b.1).abs() <= tol
}
#[test]
fn a_piece_of_a_stroke_keeps_the_widths_it_had_there() {
// An asymmetric swell along a 100-long line (command 1 draws it).
let line = Path::line(Vec2::ZERO, Vec2::new(100.0, 0.0));
let p = WidthProfile::new(vec![WidthPoint::new(0.0, 0.5, 1.0), WidthPoint::new(0.4, 3.0, 2.0), WidthPoint::new(1.0, 1.0, 0.25)]).unwrap();
// Uncut: the same profile.
let whole = p.along(&line, &[[1.0, 2.0]]).unwrap();
for (a, b) in whole.points().iter().zip(p.points()) {
assert!((a.t - b.t).abs() < 1e-5 && a.left == b.left && a.right == b.right, "{whole:?}");
}
// The stretch from 20 to 70: its point at 0.4 moves to (40 − 20) / 50 = 0.4 of the piece,
// and every place on the piece has the width it had on the stroke.
let piece = p.along(&line, &[[1.2, 1.7]]).unwrap();
for k in 0..=20 {
let u = k as f32 / 20.0;
let src = 0.2 + 0.5 * u;
assert!(near(piece.at(u), p.at(src), 0.12), "at {u}: {:?} vs {:?}", piece.at(u), p.at(src));
}
assert!(piece.points().iter().any(|w| (w.t - 0.4).abs() < 1e-4 && w.left == 3.0), "{piece:?}");
// Backwards: the far end comes first, and left and right swap.
let back = p.along(&line, &[[1.7, 1.2]]).unwrap();
for k in 0..=20 {
let u = k as f32 / 20.0;
let (l, r) = p.at(0.7 - 0.5 * u);
assert!(near(back.at(u), (r, l), 0.12), "back at {u}: {:?} vs {:?}", back.at(u), (r, l));
}
// A piece where the width holds (past the last point) has none of its own.
let flat = WidthProfile::new(vec![WidthPoint::new(0.0, 0.0, 0.0), WidthPoint::new(0.5, 2.0, 2.0)]).unwrap();
assert!(flat.along(&line, &[[1.6, 2.0]]).is_some_and(|q| q.at(0.0) == (2.0, 2.0) && q.at(1.0) == (2.0, 2.0)));
let one = WidthProfile::new(vec![WidthPoint::new(0.0, 0.0, 0.0), WidthPoint::new(0.5, 1.0, 1.0)]).unwrap();
assert!(one.along(&line, &[[1.6, 2.0]]).is_none(), "nominal all along: uniform");
}
#[test]
fn pieces_across_segments_and_hostile_spans() {
// Two segments of 50 and 50: the stretch 25..75 crosses from command 1 into command 2.
let mut path = Path::new();
path.move_to(Vec2::ZERO);
path.line_to(Vec2::new(50.0, 0.0));
path.line_to(Vec2::new(50.0, 50.0));
let p = WidthProfile::new(vec![WidthPoint::new(0.0, 1.0, 1.0), WidthPoint::new(1.0, 3.0, 3.0)]).unwrap();
let piece = p.along(&path, &[[1.5, 2.0], [2.0, 2.5]]).unwrap();
assert!(near(piece.at(0.0), p.at(0.25), 1e-3) && near(piece.at(1.0), p.at(0.75), 1e-3), "{piece:?}");
// Positions past the path, not numbers, or nothing: never a panic.
let _ = p.along(&path, &[[f64::NAN, 9.0], [-4.0, 1e300]]);
assert!(p.along(&path, &[]).is_some());
assert!(p.along(&Path::new(), &[[1.0, 2.0]]).is_some());
}
}