2bc41aeb8602
longstroke.rs
//! A long stroke without a width profile is outlined in and around the view only (`crop_line`,
//! and for dashes `dash_kept`), and draws the same pixels as when it is outlined whole.
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::{Appearance, AppearanceItem, LineCap, LineJoin, Node, StrokeLayer, WidthProfile};
use vectorcraft_geom::{PathData, Point, Vec2};
use crate::renderer::{CROP_STROKES, crop_line};
use crate::*;
const SIZE: u32 = 200;
/// A document holding `path` stroked with `st` and no fill.
fn doc(path: &BezPath, st: StrokeLayer) -> Document {
doc_with(path, vec![AppearanceItem::Stroke(st)])
}
/// A document holding `path` painted with `items`.
fn doc_with(path: &BezPath, items: Vec<AppearanceItem>) -> Document {
let mut d = Document::new(1000.0, 1000.0);
let n = Node::path(d.alloc_id(), PathData::from_bezpath(path), Appearance { items, ..Default::default() });
let l = d.layers[0].id;
d.insert(Some(l), 0, n).unwrap();
d
}
fn stroke(width: f64, join: LineJoin, cap: LineCap) -> StrokeLayer {
let mut st = StrokeLayer::new(Paint::solid(Color::BLACK), width);
st.join = join;
st.cap = cap;
st.miter_limit = 10.0;
st
}
/// The view that shows `at` in the middle of the 200×200 frame.
fn view_at(at: Point) -> Affine {
Affine::translate((100.0 - at.x, 100.0 - at.y))
}
fn render(r: &mut Renderer, d: &Document, at: Point) -> Rendered {
r.render(d, SIZE, SIZE, view_at(at), &RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() })
}
/// What a renderer that outlines every stroke whole draws.
fn whole(d: &Document, at: Point) -> Rendered {
CROP_STROKES.with(|c| c.set(false));
let mut r = Renderer::new();
let img = render(&mut r, d, at);
CROP_STROKES.with(|c| c.set(true));
assert!(r.strokes.values().all(|e| e.crop.is_none()), "the reference outlines the stroke whole");
img
}
/// 3,000 anchors 8 pt apart, up and down by 30 pt, every third segment curved: sharp miter joins.
fn zigzag() -> BezPath {
let mut bp = BezPath::new();
let at = |i: usize| Point::new(i as f64 * 8.0, if i.is_multiple_of(2) { 0.0 } else { 30.0 });
bp.move_to(at(0));
for i in 1..3000 {
if i % 3 == 0 {
bp.curve_to(at(i - 1) + Vec2::new(6.0, 0.0), at(i) + Vec2::new(-6.0, 10.0), at(i));
} else {
bp.line_to(at(i));
}
}
bp
}
#[test]
fn a_long_profile_stroke_keeps_its_widths_when_outlined_near_the_view() {
let mut lens = stroke(16.0, LineJoin::Miter, LineCap::Square);
lens.profile = WidthProfile::preset("lens");
let mut taper = stroke(12.0, LineJoin::Round, LineCap::Round);
taper.profile = WidthProfile::preset("taperEnd");
let mut asymmetric = stroke(12.0, LineJoin::Miter, LineCap::Square);
asymmetric.profile = Some(WidthProfile { points: vec![(0.0, 2.0, 0.1), (1.0, 0.1, 2.0)] });
let mut two = zigzag();
two.move_to(Point::new(0.0, 100.0));
for i in 1..3000 {
two.line_to(Point::new(i as f64 * 8.0, 100.0));
}
for (name, d, at, cropped) in [
("open zigzag, lens at middle", doc(&zigzag(), lens), Point::new(12_000.0, 15.0), true),
("open zigzag, taper at start", doc(&zigzag(), taper.clone()), Point::new(0.0, 15.0), true),
("open zigzag, taper at end", doc(&zigzag(), taper.clone()), Point::new(23_990.0, 15.0), true),
("open zigzag, asymmetric profile", doc(&zigzag(), asymmetric), Point::new(12_000.0, 15.0), true),
("two open subpaths", doc(&two, taper.clone()), Point::new(12_000.0, 60.0), true),
("closed ring at seam", doc(&ring(4000, 5000.0), taper.clone()), Point::new(5000.0, 0.0), false),
("closed ring away from seam", doc(&ring(4000, 5000.0), taper), Point::new(0.0, 5000.0), false),
] {
let mut renderer = Renderer::new();
let near = render(&mut renderer, &d, at);
assert_eq!(renderer.strokes.values().any(|e| e.crop.is_some()), cropped, "{name}: crop choice");
let full = whole(&d, at);
// The cropped outline fits cubics through the same samples, but its fit starts at the
// crop rather than at the subpath's end, so a cubic may put its control points
// differently (the same curve). The rasteriser then flattens it into a slightly
// different polygon, which shows as one level on an anti-aliased edge pixel. Anything
// more would be a wrong width.
let mismatched: Vec<_> = near
.pixels
.as_chunks::<4>()
.0
.iter()
.zip(full.pixels.as_chunks::<4>().0.iter())
.enumerate()
.filter(|(_, (a, b))| a.iter().zip(b.iter()).any(|(a, b)| a.abs_diff(*b) > 1))
.take(8)
.map(|(i, (a, b))| (i % SIZE as usize, i / SIZE as usize, a.to_vec(), b.to_vec()))
.collect();
assert!(mismatched.is_empty(), "{name}: pixels differ at {mismatched:?}");
}
}
/// A closed polygon of `n` anchors round a circle of radius `r` about the origin.
fn ring(n: usize, r: f64) -> BezPath {
let mut bp = BezPath::new();
for i in 0..n {
let t = i as f64 / n as f64 * std::f64::consts::TAU;
let p = Point::new(r * t.cos(), r * t.sin());
if i == 0 { bp.move_to(p) } else { bp.line_to(p) }
}
bp.close_path();
bp
}
#[test]
fn a_long_stroke_draws_the_same_pixels_outlined_near_the_view() {
let mut inside = stroke(8.0, LineJoin::Round, LineCap::Butt);
inside.align = vectorcraft_doc::StrokeAlign::Inside;
// The ring starts at (5000, 0): the second view is on its start and end.
let cases = [
("zigzag, miter joins, square caps", doc(&zigzag(), stroke(6.0, LineJoin::Miter, LineCap::Square)), Point::new(12_000.0, 15.0), true),
("ring, round joins", doc(&ring(4000, 5000.0), stroke(12.0, LineJoin::Round, LineCap::Round)), Point::new(0.0, 5000.0), true),
("ring through its start, bevel joins", doc(&ring(4000, 5000.0), stroke(5.0, LineJoin::Bevel, LineCap::Butt)), Point::new(5000.0, 0.0), true),
("ring, inside stroke", doc(&ring(4000, 5000.0), inside), Point::new(-5000.0, 0.0), true),
];
for (what, d, at, crops) in &cases {
let mut r = Renderer::new();
let img = render(&mut r, d, *at);
assert_eq!(r.strokes.values().any(|e| e.crop.is_some()), *crops, "{what}: outlined near the view");
assert!(img.pixels == whole(d, *at).pixels, "{what}: the same pixels as the whole outline");
// A view inside the region kept around the first one reuses the outline; one beyond it
// outlines the stroke again.
for step in [Point::new(60.0, 40.0), Point::new(450.0, 0.0), Point::new(-900.0, 300.0)] {
let next = *at + step.to_vec2();
assert!(render(&mut r, d, next).pixels == whole(d, next).pixels, "{what}, moved by {step:?}: the same pixels");
}
}
}
fn dashed(mut st: StrokeLayer, pattern: &[f64], offset: f64, align_corners: bool) -> StrokeLayer {
st.dash = Some(vectorcraft_doc::Dash { pattern: pattern.to_vec(), offset, align_corners });
st
}
/// A document holding `path` filled red and stroked with `st`.
fn filled(path: &BezPath, st: StrokeLayer) -> Document {
let fill = AppearanceItem::Fill(vectorcraft_doc::FillLayer::new(Paint::solid(Color::rgb(1.0, 0.0, 0.0))));
doc_with(path, vec![fill, AppearanceItem::Stroke(st)])
}
#[test]
fn a_long_dashed_stroke_draws_the_same_pixels_outlined_near_the_view() {
let round = stroke(6.0, LineJoin::Round, LineCap::Round);
let mut two_rings = ring(4000, 5000.0);
two_rings.extend(ring(3000, 4980.0).iter());
let cases = [
(
"zigzag, miter joins, square caps",
doc(&zigzag(), dashed(stroke(6.0, LineJoin::Miter, LineCap::Square), &[30.0, 12.0], 7.0, false)),
Point::new(12_000.0, 15.0),
),
(
"ring through its start, a dash across it",
doc(&ring(4000, 5000.0), dashed(round.clone(), &[40.0, 25.0], 0.0, false)),
Point::new(5000.0, 0.0),
),
("ring, dots", doc(&ring(4000, 5000.0), dashed(round.clone(), &[0.0, 9.0], 0.0, false)), Point::new(0.0, 5000.0)),
("ring filled, dashed", filled(&ring(4000, 5000.0), dashed(round.clone(), &[15.0, 10.0, 0.0, 10.0], 4.0, false)), Point::new(-5000.0, 0.0)),
(
"zigzag, dashes fitted to corners",
doc(&zigzag(), dashed(stroke(4.0, LineJoin::Bevel, LineCap::Butt), &[5.0, 3.0], 0.0, true)),
Point::new(8000.0, 15.0),
),
("two subpaths, dashed", doc(&two_rings, dashed(round.clone(), &[25.0, 15.0], 0.0, false)), Point::new(0.0, -4990.0)),
("a pattern too fine, drawn solid", doc(&zigzag(), dashed(round, &[0.001, 0.001], 0.0, false)), Point::new(12_000.0, 15.0)),
];
for (what, d, at) in &cases {
let mut r = Renderer::new();
let img = render(&mut r, d, *at);
assert!(r.strokes.values().any(|e| e.crop.is_some()), "{what}: outlined near the view");
assert!(img.pixels == whole(d, *at).pixels, "{what}: the same pixels as the whole outline");
assert!(img.pixels.chunks(4).any(|p| p[0] < 128), "{what}: the stroke shows");
for step in [Point::new(60.0, 40.0), Point::new(450.0, 0.0), Point::new(-900.0, 300.0)] {
let next = *at + step.to_vec2();
assert!(render(&mut r, d, next).pixels == whole(d, next).pixels, "{what}, moved by {step:?}: the same pixels");
}
}
}
/// 600 half circles of radius 60 in a row along y = 0, from x = 0, each as two quarter circles and
/// alternately above and below the row.
fn waves() -> BezPath {
let k = 60.0 * 4.0 / 3.0 * (std::f64::consts::FRAC_PI_8).tan();
let mut bp = BezPath::new();
bp.move_to((0.0, 0.0));
for i in 0..600 {
let (x, s) = (f64::from(i) * 120.0, if i % 2 == 0 { -1.0 } else { 1.0 });
bp.curve_to((x, s * k), (x + 60.0 - k, s * 60.0), (x + 60.0, s * 60.0));
bp.curve_to((x + 60.0 + k, s * 60.0), (x + 120.0, s * k), (x + 120.0, 0.0));
}
bp
}
/// Whether `outline` has a curve whose control points span 32 pt or more across or down.
fn has_long_curve(outline: &BezPath) -> bool {
outline.segments().any(|s| {
let pts = match s {
kurbo::PathSeg::Line(_) => return false,
kurbo::PathSeg::Quad(q) => vec![q.p0, q.p1, q.p2],
kurbo::PathSeg::Cubic(c) => vec![c.p0, c.p1, c.p2, c.p3],
};
let b = pts.iter().fold(kurbo::Rect::from_points(pts[0], pts[0]), |b, p| b.union_pt(*p));
b.width().max(b.height()) >= 32.0
})
}
/// A long wide stroke along curves, solid or dashed, outlined near the view has its long curves
/// drawn as lines and draws the same pixels as when it is outlined whole. With a width profile,
/// the outline made near the view keeps its curves.
#[test]
fn a_long_wide_curved_stroke_draws_the_same_pixels_outlined_near_the_view() {
let at = Point::new(36_030.0, 0.0);
let solid = stroke(24.0, LineJoin::Miter, LineCap::Butt);
for (what, d) in [("solid", doc(&waves(), solid.clone())), ("dashed", doc(&waves(), dashed(solid.clone(), &[150.0, 40.0], 0.0, false)))] {
let mut r = Renderer::new();
let near = render(&mut r, &d, at);
assert!(r.strokes.values().any(|e| e.crop.is_some()), "{what}: outlined near the view");
assert!(r.strokes.values().all(|e| !has_long_curve(&e.outline)), "{what}: its long curves drawn as lines");
assert!(near.pixels == whole(&d, at).pixels, "{what}: the same pixels as the whole outline");
assert!(near.pixels.chunks(4).any(|p| p[0] < 128), "{what}: the stroke shows");
}
let mut lens = solid;
lens.profile = WidthProfile::preset("lens");
let mut r = Renderer::new();
render(&mut r, &doc(&waves(), lens), at);
assert!(r.strokes.values().any(|e| e.crop.is_some()), "lens profile: outlined near the view");
assert!(r.strokes.values().all(|e| has_long_curve(&e.outline)), "lens profile: its curves kept");
}
#[test]
fn a_long_dashed_stroke_draws_the_same_pixels_after_its_path_changes() {
let st = dashed(stroke(5.0, LineJoin::Miter, LineCap::Butt), &[18.0, 7.0], 3.0, false);
let at = Point::new(12_000.0, 15.0);
let mut r = Renderer::new();
render(&mut r, &doc(&zigzag(), st.clone()), at);
// An anchor in the view moved, then one far before it, which shifts every dash after it.
for (i, by) in [(1501, Vec2::new(0.0, 12.0)), (40, Vec2::new(-3.0, 0.0))] {
let mut bp = zigzag();
let mut els = bp.elements().to_vec();
let Some(kurbo::PathEl::LineTo(p)) = els.get_mut(i) else {
panic!("anchor {i} is not a line");
};
*p += by;
bp = BezPath::from_vec(els);
let d = doc(&bp, st.clone());
assert!(render(&mut r, &d, at).pixels == whole(&d, at).pixels, "anchor {i} moved: the same pixels");
}
}
#[test]
fn short_dashed_strokes_are_outlined_whole() {
let st = dashed(stroke(4.0, LineJoin::Round, LineCap::Round), &[6.0, 4.0], 0.0, false);
let one = BezPath::from_vec(vec![kurbo::PathEl::MoveTo(Point::new(100.0, 100.0))]);
let mut dot = one.clone();
dot.line_to((100.0, 100.0));
for (what, bp) in
[("empty", BezPath::new()), ("one anchor", one), ("one anchor, closed on itself", dot), ("a ring of 40 anchors", ring(40, 80.0))]
{
let d = doc(&bp, st.clone());
let mut r = Renderer::new();
let img = render(&mut r, &d, Point::new(100.0, 100.0));
assert!(r.strokes.values().all(|e| e.crop.is_none()), "{what}: outlined whole");
assert!(img.pixels == whole(&d, Point::new(100.0, 100.0)).pixels, "{what}: the same pixels");
}
}
#[test]
fn a_dashed_stroke_a_wide_stroke_crosses_over_draws_the_same_pixels() {
// The closed sliver of `a_stroke_a_wide_stroke_crosses_over_stays_whole`, dashed.
let mut bp = BezPath::new();
bp.move_to((0.0, 0.0));
for i in 1..=2000 {
bp.line_to((f64::from(i) * 10.0, 0.0));
}
bp.line_to((20_000.0, 4.0));
bp.line_to((0.0, 4.0));
bp.close_path();
let d = doc(&bp, dashed(stroke(10.0, LineJoin::Miter, LineCap::Butt), &[35.0, 15.0], 0.0, false));
for at in [Point::new(20_000.0, 2.0), Point::new(9_000.0, 2.0), Point::new(0.0, 2.0)] {
let mut r = Renderer::new();
assert!(render(&mut r, &d, at).pixels == whole(&d, at).pixels, "at {at:?}: the same pixels");
}
}
/// A zigzag of 3,000 anchors 8 pt apart between y = 60 and y = 550, through the bottom of a view
/// on y = 0.
fn tall_zigzag() -> BezPath {
let mut bp = BezPath::new();
let at = |i: usize| Point::new(i as f64 * 8.0, if i.is_multiple_of(2) { 60.0 } else { 550.0 });
bp.move_to(at(0));
for i in 1..3000 {
bp.line_to(at(i));
}
bp
}
#[test]
fn a_long_stroke_under_a_wide_blur_draws_the_same_pixels_while_dragging_on_threads() {
// While dragging on threads, a drop shadow this large is drawn through a filter layer whose
// offscreen reaches 602 px past the view: the parts of the stroke that far away feed the blur.
let mut d = Document::new(1000.0, 1000.0);
let shadow = serde_json::json!({"x": 0, "y": 0, "blur": 400, "opacity": 100, "mode": "normal"});
let look = Appearance { items: vec![AppearanceItem::Stroke(stroke(20.0, LineJoin::Round, LineCap::Butt))], ..Default::default() };
let n = Node::path(d.alloc_id(), PathData::from_bezpath(&tall_zigzag()), look);
// The shadow is the group's: the path itself draws as a plain path.
let mut g = Node::group(d.alloc_id(), vec![n.into()]);
g.appearance.effects.push(vectorcraft_doc::Effect { id: "stylize.dropShadow".into(), params: shadow, visible: true });
let l = d.layers[0].id;
d.insert(Some(l), 0, g).unwrap();
let at = Point::new(12_000.0, 0.0);
let opts = RenderOptions { background: Some([255, 255, 255, 255]), dragging: true, ..Default::default() };
let draw = |crops: bool| {
CROP_STROKES.with(|c| c.set(crops));
let mut r = Renderer::new();
r.threads = 2;
let img = r.render(&d, SIZE, SIZE, view_at(at), &opts);
CROP_STROKES.with(|c| c.set(true));
(img, r.strokes.values().any(|e| e.crop.is_some()))
};
let ((near, cropped), (all, _)) = (draw(true), draw(false));
assert!(cropped, "outlined near the view");
assert!(all.pixel(100, 0)[0] < 250, "the shadow shows above the stroke: {:?}", all.pixel(100, 0));
assert!(near.pixels == all.pixels, "the same pixels as the whole outline");
}
#[test]
fn a_member_below_the_view_casts_its_wide_shadow_while_dragging_on_threads() {
// A 400 pt shadow of a group whose only member, a rectangle, lies 50 pt below the view.
let mut d = Document::new(1000.0, 1000.0);
let shadow = serde_json::json!({"x": 0, "y": 0, "blur": 400, "opacity": 100, "mode": "normal"});
let look = Appearance { items: vec![AppearanceItem::Fill(vectorcraft_doc::FillLayer::new(Paint::solid(Color::BLACK)))], ..Default::default() };
let n = Node::path(d.alloc_id(), PathData::from_bezpath(&Rect::new(-1000.0, 150.0, 1000.0, 550.0).to_path(0.1)), look);
let mut g = Node::group(d.alloc_id(), vec![n.into()]);
g.appearance.effects.push(vectorcraft_doc::Effect { id: "stylize.dropShadow".into(), params: shadow, visible: true });
let l = d.layers[0].id;
d.insert(Some(l), 0, g).unwrap();
let opts = RenderOptions { background: Some([255, 255, 255, 255]), dragging: true, ..Default::default() };
let mut r = Renderer::new();
r.threads = 2;
let img = r.render(&d, SIZE, SIZE, view_at(Point::ZERO), &opts);
assert!(img.pixel(100, 199)[0] < 200, "the shadow shows at the bottom of the view: {:?}", img.pixel(100, 199));
}
#[test]
fn a_long_stroke_is_outlined_near_the_view_only() {
let d = doc(&zigzag(), stroke(6.0, LineJoin::Miter, LineCap::Square));
let at = Point::new(12_000.0, 15.0);
let mut r = Renderer::new();
render(&mut r, &d, at);
let near = r.strokes.values().map(|e| e.outline.elements().len()).sum::<usize>();
CROP_STROKES.with(|c| c.set(false));
let mut full = Renderer::new();
render(&mut full, &d, at);
CROP_STROKES.with(|c| c.set(true));
let all = full.strokes.values().map(|e| e.outline.elements().len()).sum::<usize>();
assert!(near > 0 && near * 10 < all, "{near} outline elements near the view, {all} for the whole stroke");
}
#[test]
fn a_stroke_a_wide_stroke_crosses_over_stays_whole() {
// A closed sliver 4 pt tall: a 10 pt stroke covers it from side to side.
let mut bp = BezPath::new();
bp.move_to((0.0, 0.0));
for i in 1..=2000 {
bp.line_to((f64::from(i) * 10.0, 0.0));
}
bp.line_to((20_000.0, 4.0));
bp.line_to((0.0, 4.0));
bp.close_path();
let d = doc(&bp, stroke(10.0, LineJoin::Miter, LineCap::Butt));
let at = Point::new(20_000.0, 2.0);
let mut r = Renderer::new();
let img = render(&mut r, &d, at);
assert!(r.strokes.values().all(|e| e.crop.is_none()));
assert!(img.pixels == whole(&d, at).pixels);
}
fn path(svg: &str) -> BezPath {
BezPath::from_svg(svg).unwrap()
}
#[test]
fn crop_line_keeps_the_runs_of_segments_near_the_region() {
let region = Rect::new(0.0, 0.0, 100.0, 100.0);
let crop = |svg: &str| crop_line(&path(svg), region, 5.0, 1.0).map(|bp| bp.to_svg());
// Nothing to leave out: an empty path, one segment, a path in the region.
assert_eq!(crop(""), None);
assert_eq!(crop("M10,10 L90,90"), None);
assert_eq!(crop("M10,10 L90,90 L10,90 Z"), None);
// A segment within the reach of the region stays; one beyond it goes, and the open path is cut.
assert_eq!(crop("M50,50 L104,50 L200,50 L300,50").as_deref(), Some("M50,50 L104,50 L200,50"));
assert_eq!(crop("M50,50 L200,50 L300,50 L400,50").as_deref(), Some("M50,50 L200,50"));
// A curve whose control point reaches the region stays.
assert_eq!(crop("M200,0 C50,50 300,0 400,0 L500,0").as_deref(), Some("M200,0 C50,50 300,0 400,0"));
// Two runs, each its own open subpath.
assert_eq!(crop("M50,10 L300,10 L300,90 L50,90").as_deref(), Some("M50,10 L300,10 M300,90 L50,90"));
// Every segment goes.
assert_eq!(crop("M300,300 L400,400").as_deref(), Some(""));
// A closed subpath is walked from a segment it loses: its start stays inside one run.
assert_eq!(crop("M50,50 L50,500 L500,500 L500,50 Z").as_deref(), Some("M500,50 L50,50 L50,500"));
// A subpath with no segments stays, and so does an untouched subpath beside a cut one.
assert_eq!(crop("M900,900 M10,10 L20,20 M50,50 L300,50 L400,50").as_deref(), Some("M900,900 M10,10 L20,20 M50,50 L300,50"));
// A closed subpath that the stroke crosses over keeps all its segments.
assert_eq!(crop_line(&path("M50,0 L50,2 L500,2 L500,0 Z"), region, 5.0, 3.0), None);
// A coordinate that is not a number keeps its segment.
let mut nan = path("M50,50 L300,50 L400,50");
nan.line_to((f64::NAN, 50.0));
assert!(crop_line(&nan, region, 5.0, 1.0).is_some_and(|bp| bp.elements().iter().any(|e| e.end_point().is_some_and(|p| p.x.is_nan()))));
}
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.