VectorCraft: An open-source, vector art tool written by scratch in pure Rust
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);
}
#[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 half as wide: its top edge is 2.5 up.
assert!(param(&sl, Point::new(25.0, -2.4)).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);
}
}
}
#[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);
st.profile = WidthProfile::preset("wave");
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}");
}
}
}