2bc41aeb8602
tests_gradient.rs
use kurbo::{BezPath, Point, Shape, Vec2};
use vectorcraft_color::{Color, Gradient, GradientPaint, GradientStop, Paint};
use vectorcraft_doc::{ArrowAlign, Arrowhead, Dash, LineCap, LineJoin, StrokeAlign, StrokeGradientMode, StrokeLayer, WidthProfile};
use vectorcraft_geom::FillRule;
use super::*;
fn stroke(width: f64, mode: StrokeGradientMode) -> StrokeLayer {
let mut st = StrokeLayer::new(Paint::Gradient(Box::new(GradientPaint::new(Gradient::default()))), width);
st.gradient_mode = mode;
st
}
fn poly(pts: &[(f64, f64)], closed: bool) -> BezPath {
let mut b = BezPath::new();
b.move_to(pts[0]);
for p in &pts[1..] {
b.line_to(*p);
}
if closed {
b.close_path();
}
b
}
/// The gradient position the slices give `p` (the last slice holding it wins, as when filled).
fn param(slices: &[Slice], p: Point) -> Option<f64> {
slices.iter().rev().find(|s| s.shape.contains(p)).map(|s| {
let d = s.to - s.from;
let u = if d.hypot2() > 1e-18 { ((p - s.from).dot(d) / d.hypot2()).clamp(0.0, 1.0) } else { 0.0 };
s.span.0 + (s.span.1 - s.span.0) * u
})
}
fn slices(bp: &BezPath, st: &StrokeLayer) -> Vec<Slice> {
gradient_slices(bp, FillRule::NonZero, st, 0.01, 0.5, 0.0)
}
/// Every point the stroke paints (on a grid over each of its outlines) lies in a slice.
fn assert_covered(bp: &BezPath, st: &StrokeLayer) {
let sl = slices(bp, st);
let pieces = stroke_pieces(bp, st);
let mut parts = vec![line_outline(&pieces.line, st, aligned_width(st, is_closed(bp)), 0.01)];
parts.extend(pieces.heads.into_iter().map(|h| h.outline));
for part in &parts {
let b = part.bounding_box();
let n = 60;
for i in 0..=n {
for j in 0..=n {
let p = Point::new(b.x0 + b.width() * i as f64 / n as f64, b.y0 + b.height() * j as f64 / n as f64);
if part.contains(p) {
assert!(param(&sl, p).is_some(), "{p:?} of the stroke is in no slice ({:?})", st.join);
}
}
}
}
}
#[test]
fn span_is_the_part_of_the_gradient_between_two_positions() {
let g = Gradient::default();
let grey = |g: &Gradient, t: f32| g.sample(t).0.to_rgb()[0];
let s = g.span(0.25, 0.75);
assert_eq!(s.stops.len(), 2);
assert!((grey(&s, 0.0) - 0.75).abs() < 1e-5 && (grey(&s, 1.0) - 0.25).abs() < 1e-5);
assert!((grey(&s, 0.5) - 0.5).abs() < 1e-5);
// Backwards, and one colour when empty.
let r = g.span(0.75, 0.25);
assert!((grey(&r, 0.0) - 0.25).abs() < 1e-5 && (grey(&r, 1.0) - 0.75).abs() < 1e-5);
let c = g.span(0.4, 0.4);
assert!((grey(&c, 0.0) - grey(&c, 1.0)).abs() < 1e-6);
// Stops and off-centre midpoints inside the span keep their colours.
let mut g3 = Gradient::default();
g3.stops.insert(1, GradientStop::new(0.5, Color::rgb(1.0, 0.0, 0.0)));
g3.stops[0].midpoint = 0.25;
let s3 = g3.span(0.0, 1.0);
for t in [0.05, 0.125, 0.3, 0.5, 0.7, 0.95] {
let (a, b) = (g3.sample(t).0.to_rgb(), s3.sample(t).0.to_rgb());
assert!(a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-4), "{t}: {a:?} vs {b:?}");
}
}
#[test]
fn along_maps_the_length_of_the_path_in_any_direction() {
let st = stroke(10.0, StrokeGradientMode::Along);
for angle in [0.0f64, 37.0, 90.0, 200.0, 315.0] {
let d = Vec2::new(angle.to_radians().cos(), angle.to_radians().sin());
let start = Point::new(50.0, 50.0);
let sl = slices(&poly(&[(start.x, start.y), (start.x + 100.0 * d.x, start.y + 100.0 * d.y)], false), &st);
let n = Vec2::new(-d.y, d.x);
for (at, across) in [(25.0, 0.0), (25.0, 4.0), (25.0, -4.0), (60.0, 2.0)] {
let t = param(&sl, start + d * at + n * across).unwrap();
assert!((t - at / 100.0).abs() < 1e-6, "{angle}°: {t} at {at}");
}
// Past the ends (under caps and arrowheads) the end colours carry on.
assert_eq!(param(&sl, start - d * 0.3), Some(0.0));
// The slices hug the stroke.
assert_eq!(param(&sl, start + d * 50.0 + n * 7.0), None);
}
// Round a closed square: positions are fractions of its perimeter.
let sl = slices(&poly(&[(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)], true), &st);
assert!((param(&sl, Point::new(50.0, 2.0)).unwrap() - 0.125).abs() < 1e-6);
assert!((param(&sl, Point::new(102.0, 50.0)).unwrap() - 0.375).abs() < 1e-6);
assert!((param(&sl, Point::new(101.0, -1.0)).unwrap() - 0.25).abs() < 1e-6);
}
#[test]
fn along_keeps_a_corners_colour_round_its_outside() {
let st = stroke(20.0, StrokeGradientMode::Along);
// Right then down: the outside of the corner is up and to the right.
let sl = slices(&poly(&[(0.0, 0.0), (100.0, 0.0), (100.0, 100.0)], false), &st);
for p in [(105.0, -5.0), (109.0, -9.0), (101.0, -8.0), (108.0, -1.0)] {
assert!((param(&sl, p.into()).unwrap() - 0.5).abs() < 1e-6, "{p:?}");
}
// Inside the corner each side takes the nearest point of its own segment.
assert!((param(&sl, Point::new(92.0, 5.0)).unwrap() - 0.46).abs() < 1e-6);
assert!((param(&sl, Point::new(95.0, 8.0)).unwrap() - 0.54).abs() < 1e-6);
}
/// An Across stroke gradient runs from the stroke's left edge to its right edge, also where a width profile moves them.
#[test]
fn across_runs_from_the_left_edge_to_the_right() {
let st = stroke(10.0, StrokeGradientMode::Across);
// Travelling +x (y down), the left edge is up.
let line = poly(&[(0.0, 0.0), (100.0, 0.0)], false);
let sl = slices(&line, &st);
for (y, want) in [(-5.0, 0.0), (-2.5, 0.25), (0.0, 0.5), (4.0, 0.9), (5.0, 1.0)] {
assert!((param(&sl, Point::new(37.0, y)).unwrap() - want).abs() < 1e-6, "{y}");
}
// The same all round a curve: half way across is half way, wherever.
let sl = slices(&kurbo::Circle::new((0.0, 0.0), 60.0).to_path(1e-3), &st);
for k in 0..12 {
let dir = Vec2::from_angle(k as f64 * 0.5);
let (inner, mid) = (param(&sl, (dir * 56.0).to_point()).unwrap(), param(&sl, (dir * 60.0).to_point()).unwrap());
assert!((mid - 0.5).abs() < 0.02 && (inner - 0.5).abs() > 0.3, "{mid} {inner}");
}
// With a width profile, across runs between the stroke's edges where they are.
let mut lens = st.clone();
lens.profile = Some(WidthProfile::lens());
let sl = slices(&line, &lens);
// A quarter of the way along, the lens is three quarters as wide: its top edge is 3.75 up.
assert!(param(&sl, Point::new(25.0, -3.6)).unwrap() < 0.05);
assert!((param(&sl, Point::new(50.0, -2.5)).unwrap() - 0.25).abs() < 0.02);
}
#[test]
fn an_aligned_stroke_spans_the_gradient_across_the_side_it_shows_on() {
for align in [StrokeAlign::Inside, StrokeAlign::Outside] {
for reverse in [false, true] {
let mut st = stroke(10.0, StrokeGradientMode::Across);
st.align = align;
let mut pts = vec![(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)];
if reverse {
pts.reverse();
}
let sl = slices(&poly(&pts, true), &st);
// Across the top edge: from the path to 10 pt into the side the stroke shows on.
let dy = if align == StrokeAlign::Inside { 1.0 } else { -1.0 };
let (at_path, far) = (param(&sl, Point::new(50.0, 0.0)).unwrap(), param(&sl, Point::new(50.0, 10.0 * dy)).unwrap());
assert!((at_path - far).abs() > 0.99, "{align:?} {reverse}: {at_path} → {far}");
assert!((param(&sl, Point::new(50.0, 5.0 * dy)).unwrap() - 0.5).abs() < 1e-6);
}
}
}
/// The gradient slices cover every point the stroke paints, with each join, caps, arrowheads, a profile and dashes.
#[test]
fn slices_cover_everything_the_stroke_paints() {
let zig = poly(&[(0.0, 0.0), (60.0, 40.0), (0.0, 80.0), (70.0, 90.0), (75.0, 20.0)], false);
let mut curve = BezPath::new();
curve.move_to((0.0, 0.0));
curve.curve_to((80.0, -60.0), (120.0, 120.0), (10.0, 60.0));
let triangle = poly(&[(0.0, 0.0), (100.0, 0.0), (50.0, 30.0)], true);
for mode in [StrokeGradientMode::Along, StrokeGradientMode::Across] {
for join in [LineJoin::Miter, LineJoin::Round, LineJoin::Bevel] {
let mut st = stroke(12.0, mode);
st.join = join;
st.cap = LineCap::Square;
assert_covered(&zig, &st);
assert_covered(&curve, &st);
assert_covered(&triangle, &st);
st.start_arrow = Some(Arrowhead::Triangle);
st.end_arrow = Some(Arrowhead::CircleOpen);
assert_covered(&zig, &st);
st.arrow_align = ArrowAlign::Tip;
assert_covered(&curve, &st);
// Teardrop, not Wave: with most profiles a dash across the zigzag's sharp corner
// paints outside every slice (#5964). Back to Wave once that is fixed.
st.profile = WidthProfile::preset("teardrop");
st.dash = Some(Dash { pattern: vec![12.0, 6.0], ..Default::default() });
assert_covered(&zig, &st);
st.align = StrokeAlign::Outside;
assert_covered(&triangle, &st);
}
}
}
#[test]
fn meshes_colour_the_stroke_as_the_slices_do() {
let g = Gradient::default();
let shape = poly(&[(0.0, 0.0), (100.0, 0.0), (100.0, 60.0)], false);
for mode in [StrokeGradientMode::Along, StrokeGradientMode::Across] {
let st = stroke(10.0, mode);
let sl = slices(&shape, &st);
let meshes = gradient_meshes(&shape, FillRule::NonZero, &st, &g);
assert_eq!(meshes.len(), 1);
assert!(meshes[0].is_valid());
let quads = meshes[0].quads(4);
for p in [(25.0, 0.0), (40.0, -3.0), (70.0, 4.0), (100.0, 30.0), (98.0, 50.0), (103.0, 20.0)] {
let p = Point::new(p.0, p.1);
let want = 1.0 - param(&sl, p).unwrap();
let q = quads.iter().find(|q| poly(&q.pts.map(|v| (v.x, v.y)), true).contains(p)).expect("in the mesh");
let got = q.color.to_rgb()[0] as f64;
assert!((got - want).abs() < 0.05, "{mode:?} {p:?}: mesh {got} vs {want}");
}
}
}
/// #5964: with ribs only at the path's corners (an Along gradient), an arrowhead whose tip sits on
/// the end of a long straight leg is covered all the way to where it can reach: the ribs that
/// reach across it run to the end of its reach, rather than narrowing from its tip towards the
/// next corner and leaving the corners of its base outside.
#[test]
fn slices_cover_an_arrowhead_on_a_long_straight_leg() {
let zig = poly(&[(0.0, 0.0), (60.0, 40.0), (0.0, 80.0), (70.0, 90.0), (75.0, 20.0)], false);
for profile in [None, WidthProfile::preset("lens"), WidthProfile::preset("taperStart")] {
for align in [ArrowAlign::Tip, ArrowAlign::Extend] {
for mode in [StrokeGradientMode::Along, StrokeGradientMode::Across] {
let mut st = stroke(12.0, mode);
st.start_arrow = Some(Arrowhead::Triangle);
st.end_arrow = Some(Arrowhead::Triangle);
st.arrow_align = align;
st.profile = profile.clone();
assert_covered(&zig, &st);
}
}
}
}
/// Does the last slice holding `p` (the one filled last there) lay its gradient piece on a part of
/// the path running across the page (left or right), for a gradient in `mode`? Along, the piece
/// runs the way the path does; across, square to it.
fn painted_by_level_part(slices: &[Slice], p: Point, mode: StrokeGradientMode) -> Option<bool> {
slices.iter().rev().find(|s| s.shape.contains(p)).map(|s| {
let d = s.to - s.from;
(d.x.abs() > d.y.abs()) == (mode == StrokeGradientMode::Along)
})
}
/// #5960: where a variable-width stroke crosses itself, the later pass paints over the earlier one
/// only where the two overlap. Its slices reach as far as the stroke is wide there, not as far as
/// it is wide anywhere, so a narrow later pass leaves the wide earlier one its own colour beside it.
#[test]
fn a_narrow_pass_over_a_wide_one_paints_only_where_they_overlap() {
// Right along y = 50, round, then down through the first leg at x = 50, near the narrow end.
let crossing = poly(&[(0.0, 50.0), (100.0, 50.0), (100.0, 100.0), (50.0, 100.0), (50.0, 0.0)], false);
for mode in [StrokeGradientMode::Along, StrokeGradientMode::Across] {
let mut st = stroke(10.0, mode);
st.profile = Some(WidthProfile::taper_end());
let sl = slices(&crossing, &st);
// In the first leg (about 4 pt either side of it there) but 4 pt beside the second leg,
// which is less than 1 pt either side of itself there.
let level = painted_by_level_part(&sl, Point::new(54.0, 52.0), mode);
assert_eq!(level, Some(true), "{mode:?}: painted by the second leg");
// Where the two overlap, the second leg is on top.
let level = painted_by_level_part(&sl, Point::new(50.5, 52.0), mode);
assert_eq!(level, Some(false), "{mode:?}: painted by the first leg");
assert_covered(&crossing, &st);
}
}
/// #5960: a narrow pass running close beside a wide one doesn't paint the wide one's edge.
#[test]
fn a_narrow_pass_beside_a_wide_one_leaves_its_edge_alone() {
// Right along y = 0, then back along y = 7: the way back is the narrow end of a taper.
let hairpin = poly(&[(0.0, 0.0), (100.0, 0.0), (100.0, 7.0), (0.0, 7.0)], false);
let total = 207.0;
let mut st = stroke(10.0, StrokeGradientMode::Along);
st.profile = Some(WidthProfile::taper_end());
let sl = slices(&hairpin, &st);
// Half way along the first leg, 3 pt off it (it is about 3.8 pt wide there either side); the
// way back is about 1.2 pt wide either side there, so it reaches no nearer than 5.8.
let p = Point::new(50.0, 3.0);
let t = param(&sl, p).expect("in a slice");
assert!((t - 50.0 / total).abs() < 1e-6, "painted with {t}, not the first leg's {}", 50.0 / total);
assert_covered(&hairpin, &st);
}
/// A gradient along or across a stroke that repeats or reflects runs its stops that many times
/// along (or across) it: a slice's paint, and Outline Stroke's meshes, give each point the color
/// the spread gives its place.
#[test]
fn a_spread_gradient_runs_its_stops_along_the_stroke_that_many_times() {
use vectorcraft_color::GradientSpread;
let bp = poly(&[(0.0, 0.0), (120.0, 0.0)], false);
for (mode, spread) in [StrokeGradientMode::Along, StrokeGradientMode::Across]
.into_iter()
.flat_map(|m| [GradientSpread::Reflect, GradientSpread::Repeat].map(|s| (m, s)))
{
let mut st = stroke(10.0, mode);
let g = Gradient { spread, repeats: 3, ..Gradient::default() };
st.paint = Paint::Gradient(Box::new(GradientPaint::new(g.clone())));
for s in slices(&bp, &st) {
let Paint::Gradient(p) = s.paint(&g.unrolled()) else { panic!("a gradient slice") };
let geom = p.geom.unwrap();
for u in [0.1, 0.5, 0.9] {
let at = s.from + (s.to - s.from) * u;
let t = s.span.0 + (s.span.1 - s.span.0) * u;
// Where two runs meet, Repeat's color is the next run's start or the last one's end.
if (t * 3.0 - (t * 3.0).round()).abs() < 1e-9 {
continue;
}
let want = g.sample(g.spread_param(t) as f32).0.to_rgb();
let got = p.gradient.sample(geom.param_at(vectorcraft_color::GradientKind::Linear, at) as f32).0.to_rgb();
assert!(want.iter().zip(got).all(|(a, b)| (a - b).abs() < 1e-3), "{mode:?} at {t}: {want:?} vs {got:?}");
}
}
// Outline Stroke: the mesh comes back to white where each run starts again, and reaches
// black where each run ends, on both sides of a sharp step between runs.
let count = |g: &Gradient, hex: &str| {
gradient_meshes(&bp, FillRule::NonZero, &st, g).iter().flat_map(|m| m.points.iter()).filter(|p| p.color.to_hex() == hex).count()
};
for hex in ["#ffffff", "#000000"] {
let (spread, pad) = (count(&g, hex), count(&Gradient::default(), hex));
assert!(spread > pad, "{mode:?} {:?} {hex}: {spread} vs {pad}", g.spread);
}
}
}
/// Where a reflecting gradient turns back past a narrow last stop, Outline Stroke's mesh keeps that
/// stop's color.
#[test]
fn a_narrow_peak_where_a_reflecting_gradient_turns_back_stays_in_the_mesh() {
use vectorcraft_color::GradientSpread;
let bp = poly(&[(0.0, 0.0), (120.0, 0.0)], false);
let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(0.995, Color::BLACK), GradientStop::new(1.0, Color::WHITE)];
for mode in [StrokeGradientMode::Along, StrokeGradientMode::Across] {
let mut st = stroke(10.0, mode);
let g = Gradient { spread: GradientSpread::Reflect, repeats: 100, ..Gradient::new(vectorcraft_color::GradientKind::Linear, stops.clone()) };
st.paint = Paint::Gradient(Box::new(GradientPaint::new(g.clone())));
let whites =
gradient_meshes(&bp, FillRule::NonZero, &st, &g).iter().flat_map(|m| m.points.iter()).filter(|p| p.color.to_hex() == "#ffffff").count();
// The gradient turns back at white 50 times.
assert!(whites >= 50, "{mode:?}: {whites}");
}
}
/// Outline Stroke's mesh across a stroke of many ribs, with a gradient of many stops repeated 100
/// times: each mesh holds at most so many points, and every run still starts on its first color.
#[test]
fn a_mesh_across_many_ribs_and_stops_stays_bounded() {
use vectorcraft_color::GradientSpread;
let pts: Vec<(f64, f64)> = (0..1200).map(|i| (i as f64 * 10.0, if i % 2 == 0 { 0.0 } else { 10.0 })).collect();
let bp = poly(&pts, false);
let stops: Vec<GradientStop> = (0..200).map(|i| GradientStop::new(i as f32 / 199.0, Color::gray(1.0 - i as f32 / 199.0))).collect();
let g = Gradient { spread: GradientSpread::Repeat, repeats: 100, ..Gradient::new(vectorcraft_color::GradientKind::Linear, stops) };
let mut st = stroke(4.0, StrokeGradientMode::Across);
st.paint = Paint::Gradient(Box::new(GradientPaint::new(g.clone())));
let meshes = gradient_meshes(&bp, FillRule::NonZero, &st, &g);
assert!(!meshes.is_empty());
for m in &meshes {
assert!(m.points.len() <= super::gradient::MAX_MESH_POINTS, "{} points", m.points.len());
// A row at the start of each of the 100 runs, on every rib, is white.
let light = m.points.iter().filter(|p| p.color.to_rgb()[0] > 0.97).count();
assert!(light >= 100 * (m.cols as usize + 1), "{light} light points of {}", m.points.len());
}
// A strip of more ribs than one mesh has room for is split into meshes that share their end
// ribs, every rib in one of them.
use super::gradient::rib_pieces;
assert_eq!(rib_pieces(5, 3), [0..3, 2..5]);
assert_eq!(rib_pieces(4, 3), [0..3, 2..4]);
let one = rib_pieces(2, 1000);
assert_eq!((one.len(), one.first()), (1, Some(&(0..2))));
assert_eq!(rib_pieces(3, 0), [0..2, 1..3]);
}
/// #5960: with dashes, the ribs reach as far as the stroke gets wide within a cap's length along
/// the path, however many points lie that far: not as far as it is wide anywhere when more than
/// 256 do.
#[test]
fn a_densely_flattened_dashed_pass_beside_a_wide_one_leaves_its_edge_alone() {
// The hairpin above, the way back in 0.01 pt steps: 500 points within a round cap's 5 pt.
let mut pts = vec![(0.0, 0.0), (100.0, 0.0)];
pts.extend((0..=10_000).map(|i| (100.0 - i as f64 * 0.01, 7.0)));
let hairpin = poly(&pts, false);
let total = 207.0;
let mut st = stroke(10.0, StrokeGradientMode::Along);
st.profile = Some(WidthProfile::taper_end());
st.cap = LineCap::Round;
st.dash = Some(Dash { pattern: vec![12.0, 6.0], ..Default::default() });
let sl = slices(&hairpin, &st);
let p = Point::new(50.0, 3.0);
let t = param(&sl, p).expect("in a slice");
assert!((t - 50.0 / total).abs() < 1e-6, "painted with {t}, not the first leg's {}", 50.0 / total);
}
/// The widest the ribs ahead reach is the widest over the points out to the first one more than
/// the window along, as a walk along the subpath finds it, open and closed.
#[test]
fn widest_ahead_is_the_widest_within_the_window() {
let mut seed = 0x9e37_79b9_u64;
let mut rnd = move || {
seed = seed.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1_442_695_040_888_963_407);
(seed >> 11) as f64 / (1u64 << 53) as f64
};
for _ in 0..200 {
let n = 1 + (rnd() * 40.0) as usize;
let cover: Vec<f64> = (0..n).map(|_| rnd() * 10.0).collect();
// Some points on top of each other.
let seg: Vec<f64> = (0..n).map(|_| if rnd() < 0.2 { 0.0 } else { rnd() * 3.0 }).collect();
let window = [0.0, rnd() * 5.0, rnd() * 200.0][(rnd() * 3.0) as usize];
for closed in [false, true] {
let got = super::gradient::widest_ahead(&cover, &seg, closed, window);
assert_eq!(got.len(), n);
for (i, &got) in got.iter().enumerate() {
let (mut j, mut d, mut want) = (i, 0.0, 0.0_f64);
for _ in 0..n {
let k = if closed {
(j + 1) % n
} else if j + 1 < n {
j + 1
} else {
break;
};
want = want.max(cover[k]);
d += seg[j];
j = k;
if d > window {
break;
}
}
assert_eq!(got, want, "n {n}, closed {closed}, window {window}, point {i}");
}
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.