Files
effectcraft/crates/path/src/ops/tests.rs
T

500 lines
19 KiB
Rust
Raw 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.
use super::*;
use kurbo::{Circle, Rect, Shape};
fn len(p: &[BezPath]) -> f64 {
p.iter().map(length).sum()
}
fn sq(x: f64, y: f64, s: f64) -> BezPath {
Rect::new(x, y, x + s, y + s).to_path(0.1)
}
fn circle(x: f64, y: f64, r: f64) -> BezPath {
Circle::new((x, y), r).to_path(1e-3)
}
fn close(a: f64, b: f64, tol: f64) -> bool {
(a - b).abs() <= tol
}
fn on_curve(p: &BezPath) -> Vec<Point> {
p.elements().iter().filter_map(|e| e.end_point()).collect()
}
// ---------------------------------------------------------------- trim
#[test]
fn trim_half_square() {
let s = sq(0.0, 0.0, 100.0);
let t = trim(std::slice::from_ref(&s), 0.0, 50.0, 0.0);
assert!(close(len(&t), 200.0, 0.5), "{}", len(&t));
let t2 = trim(&[s], 0.0, 50.0, 270.0);
assert!(close(len(&t2), 200.0, 0.5));
}
#[test]
fn trim_empty_keeps_slot() {
let t = trim(&[sq(0.0, 0.0, 10.0)], 30.0, 30.0, 0.0);
assert_eq!(t.len(), 1);
assert!(t[0].elements().is_empty());
}
#[test]
fn trim_across_start_point_is_one_piece() {
// 75 %..125 % (via the offset) crosses the start of the closed path: one continuous subpath.
let t = trim(&[sq(0.0, 0.0, 100.0)], 0.0, 50.0, 270.0);
let moves = t[0].elements().iter().filter(|e| matches!(e, PathEl::MoveTo(_))).count();
assert_eq!(moves, 1, "{:?}", t[0]);
}
#[test]
fn trim_simultaneously_trims_each_path() {
let paths = [sq(0.0, 0.0, 100.0), sq(200.0, 0.0, 50.0)];
let t = trim(&paths, 0.0, 50.0, 0.0);
assert!(close(length(&t[0]), 200.0, 0.5));
assert!(close(length(&t[1]), 100.0, 0.5));
}
#[test]
fn trim_individually_is_sequential() {
let paths = [sq(0.0, 0.0, 100.0), sq(200.0, 0.0, 100.0)];
let t = trim_individually(&paths, 0.0, 50.0, 0.0);
assert!(close(length(&t[0]), 400.0, 0.5), "{}", length(&t[0]));
assert!(length(&t[1]) < 1e-6);
let t = trim_individually(&paths, 25.0, 75.0, 0.0);
assert!(close(length(&t[0]), 200.0, 0.5));
assert!(close(length(&t[1]), 200.0, 0.5));
// Unequal lengths: the kept length is the fraction of the total.
let paths = [sq(0.0, 0.0, 100.0), sq(200.0, 0.0, 25.0)];
let t = trim_individually(&paths, 10.0, 90.0, 45.0);
assert!(close(len(&t), 0.8 * 500.0, 0.5), "{}", len(&t));
}
#[test]
fn reverse_flips_orientation() {
let s = sq(0.0, 0.0, 10.0);
let r = reverse(std::slice::from_ref(&s));
assert!(close(r[0].area(), -s.area(), 1e-9));
assert_eq!(vertex_count(&r[0]), 4);
}
// ---------------------------------------------------------------- round corners
#[test]
fn round_corners_square() {
let r = round_corners(&[sq(0.0, 0.0, 100.0)], 10.0);
assert_eq!(vertex_count(&r[0]), 8);
let expect = 10000.0 - (4.0 - PI) * 100.0;
assert!(close(r[0].area().abs(), expect, 1.0), "{}", r[0].area());
// Matches the rectangle's own roundness.
let rr = crate::rect([100.0, 100.0], [50.0, 50.0], 10.0);
assert!(close(rr.area().abs(), r[0].area().abs(), 1.0));
}
#[test]
fn round_corners_clamps_to_half_segment() {
let r = round_corners(&[sq(0.0, 0.0, 20.0)], 100.0);
assert!(close(r[0].area().abs(), PI * 100.0, 2.0), "{}", r[0].area());
}
#[test]
fn round_corners_keeps_smooth_and_open_ends() {
let c = circle(0.0, 0.0, 50.0);
let r = round_corners(std::slice::from_ref(&c), 10.0);
assert_eq!(vertex_count(&r[0]), vertex_count(&c));
let mut open = BezPath::new();
open.move_to((0.0, 0.0));
open.line_to((100.0, 0.0));
open.line_to((100.0, 100.0));
let r = round_corners(&[open], 20.0);
assert_eq!(vertex_count(&r[0]), 4);
let pts = on_curve(&r[0]);
assert_eq!(pts[0], Point::new(0.0, 0.0));
assert!(pts.last().unwrap().distance(Point::new(100.0, 100.0)) < 1e-9);
}
#[test]
fn round_corners_triangle_arc_is_tangent() {
let mut t = BezPath::new();
t.move_to((0.0, 0.0));
t.line_to((100.0, 0.0));
t.line_to((50.0, 80.0));
t.close_path();
let r = round_corners(std::slice::from_ref(&t), 15.0);
assert_eq!(vertex_count(&r[0]), 6);
assert!(r[0].area().abs() < t.area().abs());
assert!(r[0].area().abs() > t.area().abs() - 3.0 * 15.0 * 15.0);
}
// ---------------------------------------------------------------- offset
#[test]
fn offset_grows_square_with_miter() {
let o = offset(&[sq(0.0, 0.0, 100.0)], 10.0, Join::Miter, 4.0, 1.0, 0.0);
assert!(close(area(&o), 120.0 * 120.0, 1.0), "{}", area(&o));
let b = o[0].bounding_box();
assert!(close(b.x0, -10.0, 1e-3) && close(b.x1, 110.0, 1e-3));
}
#[test]
fn offset_round_join_adds_perimeter_times_d() {
let o = offset(&[sq(0.0, 0.0, 100.0)], 10.0, Join::Round, 4.0, 1.0, 0.0);
let expect = 10000.0 + 400.0 * 10.0 + PI * 100.0;
assert!(close(area(&o), expect, 2.0), "{} vs {expect}", area(&o));
let o = offset(&[sq(0.0, 0.0, 100.0)], 10.0, Join::Bevel, 4.0, 1.0, 0.0);
let expect = 10000.0 + 400.0 * 10.0 + 4.0 * 50.0;
assert!(close(area(&o), expect, 2.0), "{} vs {expect}", area(&o));
}
#[test]
fn offset_negative_shrinks() {
let o = offset(&[sq(0.0, 0.0, 100.0)], -10.0, Join::Miter, 4.0, 1.0, 0.0);
assert!(close(area(&o), 80.0 * 80.0, 1.0), "{}", area(&o));
let gone = offset(&[sq(0.0, 0.0, 100.0)], -60.0, Join::Miter, 4.0, 1.0, 0.0);
assert!(area(&gone) < 1e-6);
}
#[test]
fn offset_circle_is_a_circle() {
let o = offset(&[circle(0.0, 0.0, 50.0)], 10.0, Join::Round, 4.0, 1.0, 0.0);
assert!(close(area(&o), PI * 3600.0, 3600.0 * PI * 1e-3), "{}", area(&o));
let o = offset(&[circle(0.0, 0.0, 50.0)], -20.0, Join::Round, 4.0, 1.0, 0.0);
assert!(close(area(&o), PI * 900.0, 900.0 * PI * 1e-3), "{}", area(&o));
// Curves stay curves (no polygon flattening blow-up).
assert!(vertex_count(&o[0]) < 40, "{}", vertex_count(&o[0]));
}
#[test]
fn offset_is_independent_of_orientation() {
let s = sq(0.0, 0.0, 100.0);
let a = offset(std::slice::from_ref(&s), 5.0, Join::Miter, 4.0, 1.0, 0.0);
let b = offset(&reverse(&[s]), 5.0, Join::Miter, 4.0, 1.0, 0.0);
assert!(close(area(&a), area(&b), 1e-3));
}
#[test]
fn offset_copies() {
let o = offset(&[sq(0.0, 0.0, 100.0)], 10.0, Join::Miter, 4.0, 3.0, 0.0);
let contours = o[0].elements().iter().filter(|e| matches!(e, PathEl::MoveTo(_))).count();
assert_eq!(contours, 3);
assert!(close(o[0].bounding_box().width(), 160.0, 1e-3));
let o = offset(&[sq(0.0, 0.0, 100.0)], 10.0, Join::Miter, 4.0, 1.0, 1.0);
assert!(close(o[0].bounding_box().width(), 140.0, 1e-3));
}
#[test]
fn offset_copies_are_budgeted_by_the_output_they_return() {
// An open one-segment subpath comes back as a closed outline of several elements, so the copies
// stop when the returned elements pass the budget, not when the input segments would.
let line = || {
let mut p = BezPath::new();
p.move_to((0.0, 0.0));
p.line_to((50.0, 0.0));
p
};
let one = offset_within(&[line()], 5.0, Join::Round, 4.0, 1.0, 0.0, usize::MAX)[0].elements().len();
assert!(one > 4, "{one}");
let o = offset_within(&[line()], 5.0, Join::Round, 4.0, 50.0, 0.0, one * 3);
let moves = o[0].elements().iter().filter(|e| matches!(e, PathEl::MoveTo(_))).count();
assert!((1..50).contains(&moves) && o[0].elements().len() <= one * 4, "{moves} contours, {} elements", o[0].elements().len());
// The first copy always comes back, however small the budget.
assert!(!offset_within(&[line()], 5.0, Join::Round, 4.0, 5.0, 0.0, 0)[0].elements().is_empty());
}
#[test]
fn offset_open_path_outlines() {
let mut l = BezPath::new();
l.move_to((0.0, 0.0));
l.line_to((100.0, 0.0));
let o = offset(&[l], 5.0, Join::Miter, 4.0, 1.0, 0.0);
assert!(close(area(&o), 1000.0, 1.0), "{}", area(&o));
}
// ---------------------------------------------------------------- pucker & bloat
#[test]
fn bloat_moves_vertices_inwards_and_bulges() {
let s = sq(-50.0, -50.0, 100.0);
let b = pucker_bloat(std::slice::from_ref(&s), 50.0);
for p in on_curve(&b[0]) {
assert!(close(p.x.abs(), 25.0, 1e-9) && close(p.y.abs(), 25.0, 1e-9), "{p:?}");
}
// Handles pushed outwards: the shape reaches beyond its vertices.
let bb = b[0].bounding_box();
assert!(bb.width() > 50.0 + 1.0, "{bb:?}");
}
#[test]
fn pucker_moves_vertices_outwards() {
let s = sq(-50.0, -50.0, 100.0);
let p = pucker_bloat(std::slice::from_ref(&s), -50.0);
for q in on_curve(&p[0]) {
assert!(close(q.x.abs(), 75.0, 1e-9) && close(q.y.abs(), 75.0, 1e-9));
}
assert!(area(&p) < area(&[s]) * 2.25, "segments pulled in");
assert_eq!(pucker_bloat(&[sq(0.0, 0.0, 1.0)], 0.0)[0], sq(0.0, 0.0, 1.0));
}
// ---------------------------------------------------------------- twist
#[test]
fn twist_rotates_by_distance() {
let mut l = BezPath::new();
l.move_to((0.0, 0.0));
l.line_to((100.0, 0.0));
let t = twist(&[l], 90.0, [0.0, 0.0]);
let pts = on_curve(&t[0]);
assert!(pts[0].distance(Point::ZERO) < 1e-9, "centre is fixed");
let end = *pts.last().unwrap();
assert!(end.distance(Point::new(0.0, 100.0)) < 1e-9, "{end:?}");
// Every on-curve point keeps its distance from the centre (it is a rotation per radius).
for p in &pts {
let r = p.distance(Point::ZERO);
let ang = p.y.atan2(p.x);
assert!(close(ang, PI / 2.0 * r / 100.0, 1e-9), "{p:?}");
}
assert!(pts.len() > 4, "subdivided");
}
#[test]
fn twist_of_centred_circle_keeps_it_round() {
let c = circle(0.0, 0.0, 50.0);
let t = twist(std::slice::from_ref(&c), 120.0, [0.0, 0.0]);
assert!(close(area(&t), area(&[c]), 1.0));
let id = twist(&[sq(0.0, 0.0, 5.0)], 0.0, [0.0, 0.0]);
assert_eq!(id[0], sq(0.0, 0.0, 5.0));
}
#[test]
fn twist_keeps_requested_detail_when_the_whole_request_fits_the_budget() {
// One long segment asks for 64 pieces; 20,000 tiny ones ask for one each. Together that is
// far under the budget, so the long one is not cut to what a uniform 64 per segment would allow.
let mut long = BezPath::new();
long.move_to((0.0, 0.0));
long.line_to((5000.0, 0.0));
let mut tiny = BezPath::new();
tiny.move_to((0.0, 1.0));
for i in 1..=20_000 {
tiny.line_to((i as f64 * 1e-3, 1.0));
}
let t = twist(&[long, tiny], 90.0, [0.0, 0.0]);
assert_eq!(t[0].elements().len(), 1 + 64);
}
// ---------------------------------------------------------------- zig zag
#[test]
fn zigzag_vertex_counts() {
let z = zigzag(&[sq(0.0, 0.0, 100.0)], 5.0, 5.0, false);
assert_eq!(vertex_count(&z[0]), 24);
let mut l = BezPath::new();
l.move_to((0.0, 0.0));
l.line_to((100.0, 0.0));
let z = zigzag(&[l], 5.0, 3.0, false);
assert_eq!(vertex_count(&z[0]), 5);
let pts = on_curve(&z[0]);
for (i, p) in pts.iter().enumerate() {
assert!(close(p.x, 25.0 * i as f64, 1e-6));
assert!(close(p.y.abs(), 5.0, 1e-9));
if i > 0 {
assert!(p.y * pts[i - 1].y < 0.0, "alternates");
}
}
}
#[test]
fn zigzag_smooth_uses_curves() {
let z = zigzag(&[sq(0.0, 0.0, 100.0)], 5.0, 2.0, true);
assert!(z[0].elements().iter().any(|e| matches!(e, PathEl::CurveTo(..))));
assert_eq!(vertex_count(&z[0]), 12);
let corner = zigzag(&[sq(0.0, 0.0, 100.0)], 5.0, 2.0, false);
assert!(!corner[0].elements().iter().any(|e| matches!(e, PathEl::CurveTo(..))));
}
// ---------------------------------------------------------------- wiggle
#[test]
fn wiggle_is_deterministic_and_time_varying() {
let s = [sq(0.0, 0.0, 100.0)];
let w = WiggleParams::default();
let a = wiggle(&s, &w, 0.5);
assert_eq!(a, wiggle(&s, &w, 0.5));
assert_ne!(a, wiggle(&s, &w, 0.75));
assert_ne!(a, wiggle(&s, &WiggleParams { seed: 3.0, ..w }, 0.5));
// Phase of 360° = one wiggle period at speed 1: same as advancing time by one second.
let w1 = WiggleParams { speed: 1.0, ..w };
assert_eq!(wiggle(&s, &WiggleParams { phase_deg: 360.0, ..w1 }, 0.25), wiggle(&s, &w1, 1.25));
assert_eq!(vertex_count(&a[0]), 4 * 11);
}
#[test]
fn wiggle_survives_an_absurd_speed_or_time() {
// `t` far past i64 saturates the lattice index at i64::MAX, and the neighbours' `+ 1`, `+ 2` used to overflow.
let s = [sq(0.0, 0.0, 100.0)];
for v in [f64::INFINITY, f64::NEG_INFINITY, f64::NAN, f64::MAX, f64::MIN, 1e300, 9.3e18] {
let by_speed = wiggle(&s, &WiggleParams { speed: v, ..Default::default() }, 1.0);
let by_time = wiggle(&s, &WiggleParams::default(), v);
let by_phase = wiggle(&s, &WiggleParams { phase_deg: v, ..Default::default() }, 0.0);
assert_eq!((by_speed.len(), by_time.len(), by_phase.len()), (1, 1, 1), "wiggle with {v}");
}
}
#[test]
fn wiggle_displacement_is_bounded() {
let mut l = BezPath::new();
l.move_to((0.0, 0.0));
l.line_to((1000.0, 0.0));
let w = WiggleParams { size: 7.0, detail: 50.0, smooth: false, ..Default::default() };
for t in [0.0, 0.3, 1.7, 9.1] {
let r = wiggle(std::slice::from_ref(&l), &w, t);
let pts = on_curve(&r[0]);
assert_eq!(pts.len(), 52);
assert!(pts.iter().all(|p| p.y.abs() <= 7.0 * 1.0001));
assert!(pts.iter().any(|p| p.y.abs() > 0.1));
}
}
#[test]
fn wiggle_full_correlation_translates() {
let s = [sq(0.0, 0.0, 100.0)];
let w = WiggleParams { correlation: 100.0, smooth: false, ..Default::default() };
let r = wiggle(&s, &w, 0.4);
assert!(close(area(&r), 10000.0, 1e-6));
let zero = wiggle(&s, &WiggleParams { size: 0.0, ..w }, 1.0);
assert_eq!(zero[0], s[0]);
}
/// Spatial Phase moves the pattern of displacements along the path: 360° is once around, and a
/// whole number of points' worth gives each point the displacement of the point that far ahead.
#[test]
fn wiggle_spatial_phase_moves_the_pattern_along_the_path() {
let s = [sq(0.0, 0.0, 100.0)];
let w = WiggleParams { detail: 3.0, correlation: 0.0, smooth: false, ..Default::default() };
// Displacements are proportional to Size: twice the size less once the size.
let disp = |w: WiggleParams| -> Vec<Vec2> {
let a = on_curve(&wiggle(&s, &w, 0.4)[0]);
let b = on_curve(&wiggle(&s, &WiggleParams { size: w.size * 2.0, ..w }, 0.4)[0]);
a.iter().zip(&b).map(|(a, b)| *b - *a).take(16).collect()
};
let d0 = disp(w);
let n = d0.len();
assert_eq!(n, 16);
for k in [1, 5] {
let dk = disp(WiggleParams { spatial_phase_deg: 360.0 * k as f64 / n as f64, ..w });
for j in 0..n {
let e = d0[(j + k) % n];
assert!(close(dk[j].x, e.x, 1e-9) && close(dk[j].y, e.y, 1e-9), "{k} ahead, point {j}: {:?} vs {e:?}", dk[j]);
}
}
// Whole turns either way leave the path as it is.
let base = wiggle(&s, &w, 0.4);
assert_eq!(wiggle(&s, &WiggleParams { spatial_phase_deg: 360.0, ..w }, 0.4), base);
assert_eq!(wiggle(&s, &WiggleParams { spatial_phase_deg: -720.0, ..w }, 0.4), base);
// Half a point ahead, the displacements change and stay within Size.
let half = disp(WiggleParams { spatial_phase_deg: 180.0 / n as f64, ..w });
assert!(half.iter().zip(&d0).any(|(h, d)| (*h - *d).hypot() > 1e-3));
assert!(half.iter().all(|h| h.x.abs() <= 10.0 + 1e-9 && h.y.abs() <= 10.0 + 1e-9));
}
// ---------------------------------------------------------------- merge / booleans
fn inclusion_exclusion(a: BezPath, b: BezPath) {
let aa = area(std::slice::from_ref(&a));
let ab = area(std::slice::from_ref(&b));
let pair = [a, b];
let u = area(&[merge(&pair, MergeMode::Add)]);
let i = area(&[merge(&pair, MergeMode::Intersect)]);
let s = area(&[merge(&pair, MergeMode::Subtract)]);
let x = area(&[merge(&pair, MergeMode::Exclude)]);
let tol = 1e-3 * (aa + ab);
assert!(i > 1.0, "overlapping");
assert!(close(u, aa + ab - i, tol), "union {u} vs {aa}+{ab}-{i}");
assert!(close(s, aa - i, tol), "subtract {s}");
assert!(close(x, u - i, tol), "exclude {x}");
}
#[test]
fn merge_rects_inclusion_exclusion() {
inclusion_exclusion(sq(0.0, 0.0, 100.0), sq(50.0, 30.0, 100.0));
let i = merge(&[sq(0.0, 0.0, 100.0), sq(50.0, 30.0, 100.0)], MergeMode::Intersect);
assert!(close(area(&[i]), 50.0 * 70.0, 1e-6));
}
#[test]
fn merge_circles_inclusion_exclusion() {
inclusion_exclusion(circle(0.0, 0.0, 50.0), circle(40.0, 10.0, 35.0));
// Curves are preserved: the union of two circles has few vertices.
let u = merge(&[circle(0.0, 0.0, 50.0), circle(40.0, 10.0, 35.0)], MergeMode::Add);
assert!(vertex_count(&u) < 20, "{}", vertex_count(&u));
}
#[test]
fn merge_modes_edge_cases() {
let a = sq(0.0, 0.0, 10.0);
let b = sq(100.0, 0.0, 10.0);
assert!(area(&[merge(&[a.clone(), b.clone()], MergeMode::Intersect)]) < 1e-9);
assert!(close(area(&[merge(&[a.clone(), b.clone()], MergeMode::Add)]), 200.0, 1e-6));
let m = merge(&[a.clone(), b.clone()], MergeMode::Merge);
assert_eq!(m.elements().len(), a.elements().len() + b.elements().len());
// Subtract with three operands: first minus the rest.
let s = merge(&[sq(0.0, 0.0, 100.0), sq(0.0, 0.0, 50.0), sq(50.0, 50.0, 50.0)], MergeMode::Subtract);
assert!(close(area(&[s]), 5000.0, 1e-6));
assert!(merge(&[], MergeMode::Add).elements().is_empty());
}
#[test]
fn normalize_and_filled_area() {
// Two same-direction overlapping squares in one path: non-zero fills the union.
let mut p = sq(0.0, 0.0, 100.0);
p.extend(sq(50.0, 0.0, 100.0).elements().iter().copied());
assert!(close(crate::boolean::filled_area(&p, FillRule::NonZero), 15000.0, 1e-6));
assert!(close(crate::boolean::filled_area(&p, FillRule::EvenOdd), 10000.0, 1e-6));
let n = crate::boolean::normalize(&p, FillRule::EvenOdd);
assert!(close(n.area().abs(), 10000.0, 1e-6));
}
// ---------------------------------------------------------------- operator budget
#[test]
fn stacked_expanding_operators_stay_within_the_segment_budget() {
// Three Zig Zags at 1000 ridges would turn a square into 4 · 1001³ segments; each output
// is held to the budget instead, and the last operators still pass the geometry through.
let mut p = vec![sq(0.0, 0.0, 100.0)];
for _ in 0..3 {
p = zigzag(&p, 1.0, 1000.0, false);
let n: usize = p.iter().map(|q| q.elements().len()).sum();
assert!(n <= 2 * MAX_OPERATOR_SEGMENTS, "{n}");
}
let w = wiggle(&p, &WiggleParams { detail: 1000.0, ..Default::default() }, 0.0);
let n: usize = w.iter().map(|q| q.elements().len()).sum();
assert!(n <= 2 * MAX_OPERATOR_SEGMENTS, "{n}");
let o = offset(&[sq(0.0, 0.0, 100.0)], 1.0, Join::Miter, 4.0, 1000.0, 0.0);
assert!(!o[0].elements().is_empty());
// Within the budget nothing changes: 4 segments × 11 pieces.
assert_eq!(vertex_count(&zigzag(&[sq(0.0, 0.0, 100.0)], 1.0, 10.0, false)[0]), 44);
}
#[test]
fn many_short_open_paths_keep_their_requested_detail_within_the_budget() {
// 1000 open lines at 1000 ridges: 1,001,000 segments fit the budget, so nothing is reduced.
let lines: Vec<BezPath> = (0..1000)
.map(|i| {
let mut p = BezPath::new();
p.move_to((0.0, i as f64));
p.line_to((100.0, i as f64));
p
})
.collect();
let z = zigzag(&lines, 1.0, 1000.0, false);
assert!(z.iter().all(|q| q.elements().len() == 1 + 1001));
}
#[test]
fn open_subpaths_reserve_one_element_of_overhead() {
// 349,525 open lines: the move-to is the only extra element, so 2 copies fit the budget
// (a closed subpath's extra close-path would leave room for 1).
let line = BezPath::from_vec(vec![PathEl::MoveTo((0.0, 0.0).into()), PathEl::LineTo((1.0, 0.0).into())]);
let lines = vec![line; 349_525];
assert_eq!(pieces_within_budget(&lines, 3), 2);
}