556 lines
24 KiB
Rust
556 lines
24 KiB
Rust
//! Morph between two outlines: one shape turns into another (a circle into a star).
|
|
//!
|
|
//! The approach is manim's: both outlines get the same number of contours and each contour pair the
|
|
//! same number of cubic curves, then every control point moves in a straight line. On top of that,
|
|
//! closed contours are turned and reversed so that their points travel as short a way as possible
|
|
//! (a triangle does not twist on its way into a circle), and extra points go to the longest curves.
|
|
|
|
use kurbo::{BezPath, PathEl, Point, Rect, Vec2};
|
|
|
|
use crate::preset::{FillMode, Geometry, SubPath};
|
|
|
|
/// A contour as cubic curves: the start anchor, then three points per curve (handle, handle,
|
|
/// anchor).
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct Contour {
|
|
pub closed: bool,
|
|
pub pts: Vec<Point>,
|
|
}
|
|
|
|
impl Contour {
|
|
pub fn curves(&self) -> usize {
|
|
self.pts.len().saturating_sub(1) / 3
|
|
}
|
|
}
|
|
|
|
fn line_to(p: &mut Vec<Point>, to: Point) {
|
|
let Some(&from) = p.last() else { return };
|
|
p.extend([from.lerp(to, 1.0 / 3.0), from.lerp(to, 2.0 / 3.0), to]);
|
|
}
|
|
|
|
fn close(c: &mut Contour) {
|
|
if let (Some(&first), Some(&last)) = (c.pts.first(), c.pts.last())
|
|
&& first != last
|
|
{
|
|
line_to(&mut c.pts, first);
|
|
}
|
|
c.closed = true;
|
|
}
|
|
|
|
fn pen(cur: &mut Option<Contour>, start: Point) -> &mut Contour {
|
|
cur.get_or_insert_with(|| Contour { closed: false, pts: vec![start] })
|
|
}
|
|
|
|
fn keep(c: Contour, out: &mut Vec<Contour>) {
|
|
if c.curves() > 0 && c.pts.iter().all(|p| p.is_finite()) {
|
|
out.push(c);
|
|
}
|
|
}
|
|
|
|
/// The contours of a path, every segment as a cubic curve. Contours without a curve or with
|
|
/// non-finite points are left out.
|
|
pub fn contours(path: &BezPath) -> Vec<Contour> {
|
|
let mut out = Vec::new();
|
|
let mut cur: Option<Contour> = None;
|
|
let mut start = Point::ZERO;
|
|
for el in path.elements() {
|
|
match *el {
|
|
PathEl::MoveTo(p) => {
|
|
if let Some(c) = cur.take() {
|
|
keep(c, &mut out);
|
|
}
|
|
start = p;
|
|
cur = Some(Contour { closed: false, pts: vec![p] });
|
|
}
|
|
PathEl::LineTo(p) => line_to(&mut pen(&mut cur, start).pts, p),
|
|
PathEl::QuadTo(q, p) => {
|
|
let c = pen(&mut cur, start);
|
|
if let Some(&a) = c.pts.last() {
|
|
c.pts.extend([a.lerp(q, 2.0 / 3.0), p.lerp(q, 2.0 / 3.0), p]);
|
|
}
|
|
}
|
|
PathEl::CurveTo(a, b, p) => pen(&mut cur, start).pts.extend([a, b, p]),
|
|
PathEl::ClosePath => {
|
|
if let Some(mut c) = cur.take()
|
|
&& c.curves() > 0
|
|
{
|
|
close(&mut c);
|
|
keep(c, &mut out);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if let Some(c) = cur {
|
|
keep(c, &mut out);
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Contours back to a path.
|
|
pub fn to_path(cs: &[Contour]) -> BezPath {
|
|
let mut bp = BezPath::new();
|
|
for c in cs {
|
|
let Some(&s) = c.pts.first() else { continue };
|
|
bp.move_to(s);
|
|
for [a, b, p] in c.pts.get(1..).unwrap_or(&[]).as_chunks::<3>().0 {
|
|
bp.curve_to(*a, *b, *p);
|
|
}
|
|
if c.closed {
|
|
bp.close_path();
|
|
}
|
|
}
|
|
bp
|
|
}
|
|
|
|
// --- alignment ---------------------------------------------------------------------------------
|
|
|
|
/// Rough curve length: mean of chord and control polygon.
|
|
fn curve_length(c: &[Point]) -> f64 {
|
|
let [p0, p1, p2, p3] = c else { return 0.0 };
|
|
(p0.distance(*p3) + p0.distance(*p1) + p1.distance(*p2) + p2.distance(*p3)) / 2.0
|
|
}
|
|
|
|
/// Appends curve `c` (four points) split into `n` pieces of equal parameter length (de Casteljau),
|
|
/// without its start anchor.
|
|
fn split_curve(c: &[Point], n: usize, out: &mut Vec<Point>) {
|
|
let [a, b, d, e] = c else { return };
|
|
let (mut p0, mut p1, mut p2, p3) = (*a, *b, *d, *e);
|
|
for j in (2..=n).rev() {
|
|
let t = 1.0 / j as f64;
|
|
let (ab, bc, cd) = (p0.lerp(p1, t), p1.lerp(p2, t), p2.lerp(p3, t));
|
|
let (abc, bcd) = (ab.lerp(bc, t), bc.lerp(cd, t));
|
|
let m = abc.lerp(bcd, t);
|
|
out.extend([ab, abc, m]);
|
|
(p0, p1, p2) = (m, bcd, cd);
|
|
}
|
|
out.extend([p1, p2, p3]);
|
|
}
|
|
|
|
/// Brings a contour to `n` curves. Unlike manim (which splits every curve equally often), the extra
|
|
/// splits go to the longest pieces, so a long side gets more points than a short one.
|
|
fn refine(c: &Contour, n: usize) -> Contour {
|
|
let have = c.curves();
|
|
if have >= n || have == 0 {
|
|
return c.clone();
|
|
}
|
|
let curves: Vec<&[Point]> = (0..have).filter_map(|k| c.pts.get(3 * k..3 * k + 4)).collect();
|
|
let len: Vec<f64> = curves.iter().map(|q| curve_length(q) + 1e-9).collect();
|
|
let mut parts = vec![1usize; curves.len()];
|
|
for _ in 0..n - have {
|
|
let share = |k: usize| len.get(k).copied().unwrap_or(0.0) / parts.get(k).copied().unwrap_or(1) as f64;
|
|
let best = (1..curves.len()).fold(0, |b, k| if share(k) > share(b) { k } else { b });
|
|
if let Some(p) = parts.get_mut(best) {
|
|
*p += 1;
|
|
}
|
|
}
|
|
let mut out = Vec::with_capacity(1 + 3 * n);
|
|
out.extend(c.pts.first().copied());
|
|
for (q, p) in curves.iter().zip(&parts) {
|
|
split_curve(q, *p, &mut out);
|
|
}
|
|
Contour { closed: c.closed, pts: out }
|
|
}
|
|
|
|
const MIN_CURVES: usize = 12;
|
|
const MAX_CURVES: usize = 60;
|
|
/// Start points tried per closed contour; longer contours are sampled evenly.
|
|
const MAX_TRIES: usize = 128;
|
|
|
|
/// How many curves a contour pair gets: a common multiple of both counts while that stays small
|
|
/// (then a triangle meets a circle at matching places and the morph stays symmetric), and at least
|
|
/// [`MIN_CURVES`] for a smooth middle.
|
|
fn curves_for(na: usize, nb: usize) -> usize {
|
|
fn gcd(x: usize, y: usize) -> usize {
|
|
if y == 0 { x } else { gcd(y, x % y) }
|
|
}
|
|
let hi = na.max(nb).max(1);
|
|
let mut n = if na > 0 && nb > 0 { (na / gcd(na, nb)).saturating_mul(nb) } else { hi };
|
|
if n > MAX_CURVES {
|
|
n = hi;
|
|
}
|
|
n.saturating_mul(MIN_CURVES.div_ceil(n).max(1))
|
|
}
|
|
|
|
/// Box around all points, handles included.
|
|
fn bounds<'a>(pts: impl IntoIterator<Item = &'a Point>) -> Option<Rect> {
|
|
pts.into_iter().fold(None, |r: Option<Rect>, p| Some(r.map_or(Rect::from_points(*p, *p), |r| r.union_pt(*p))))
|
|
}
|
|
|
|
fn center(pts: &[Point]) -> Point {
|
|
bounds(pts).map(|r| r.center()).unwrap_or(Point::ZERO)
|
|
}
|
|
|
|
/// The same contour, starting at anchor `s`, optionally run backwards.
|
|
fn turn(pts: &[Point], s: usize, back: bool) -> Vec<Point> {
|
|
let q: Vec<Point> = if back { pts.iter().rev().copied().collect() } else { pts.to_vec() };
|
|
if s == 0 {
|
|
return q;
|
|
}
|
|
let body = q.get(1..).unwrap_or(&[]);
|
|
let cut = (3 * s).min(body.len());
|
|
let mut out = Vec::with_capacity(q.len());
|
|
out.extend(cut.checked_sub(1).and_then(|i| body.get(i)).copied());
|
|
out.extend_from_slice(body.get(cut..).unwrap_or(&[]));
|
|
out.extend_from_slice(body.get(..cut).unwrap_or(&[]));
|
|
out
|
|
}
|
|
|
|
/// One contour pair of equal curve count: `b` runs backwards if `back` is set, then the closed side
|
|
/// (`b` if it is closed, else `a`) gets the start that lets the points travel least. Both sides are
|
|
/// compared around their own centre, so where the shapes are does not matter.
|
|
fn match_pair(a: &Contour, b: &Contour, back: bool) -> (Contour, Contour, f64) {
|
|
let bp = if back { turn(&b.pts, 0, true) } else { b.pts.clone() };
|
|
let turn_a = !b.closed && a.closed;
|
|
let (fixed, free) = if turn_a { (&bp, &a.pts) } else { (&a.pts, &bp) };
|
|
let (fc, gc) = (center(fixed), center(free));
|
|
let tries = if turn_a || b.closed { free.len().saturating_sub(1) / 3 } else { 1 };
|
|
let mut best = free.clone();
|
|
let mut best_cost = f64::INFINITY;
|
|
for s in (0..tries.max(1)).step_by(tries.div_ceil(MAX_TRIES).max(1)) {
|
|
let q = turn(free, s, false);
|
|
let mut cost = 0.0;
|
|
for (p, f) in q.iter().zip(fixed.iter()) {
|
|
cost += ((*p - gc) - (*f - fc)).hypot2();
|
|
if cost >= best_cost {
|
|
break;
|
|
}
|
|
}
|
|
if cost < best_cost {
|
|
best_cost = cost;
|
|
best = q;
|
|
}
|
|
}
|
|
let (pa, pb) = if turn_a { (best, bp) } else { (a.pts.clone(), best) };
|
|
(Contour { closed: a.closed, pts: pa }, Contour { closed: b.closed, pts: pb }, best_cost)
|
|
}
|
|
|
|
/// Where a contour without partner shrinks to (or grows from): the spot at the same place relative
|
|
/// to the other outline's box, or its own centre without one.
|
|
fn place(c: &Contour, from: Option<Rect>, to: Option<Rect>) -> Point {
|
|
let p = center(&c.pts);
|
|
let (Some(from), Some(to)) = (from, to) else { return p };
|
|
let fx = if from.width() > 0.0 { (p.x - from.x0) / from.width() } else { 0.5 };
|
|
let fy = if from.height() > 0.0 { (p.y - from.y0) / from.height() } else { 0.5 };
|
|
Point::new(to.x0 + to.width() * fx, to.y0 + to.height() * fy)
|
|
}
|
|
|
|
/// Two contour lists brought to the same number of contours and the same number of curves per
|
|
/// contour pair. Contours pair up in order; one without partner meets a point (see [`place`];
|
|
/// `ba`/`bb` are the boxes of the whole outlines). Whether `b` runs backwards is decided once for all
|
|
/// its contours: turning single ones around would change which areas a nonzero fill covers.
|
|
pub fn align(a: &[Contour], b: &[Contour], ba: Option<Rect>, bb: Option<Rect>) -> (Vec<Contour>, Vec<Contour>) {
|
|
// (a, b, either side a point).
|
|
let mut pairs: Vec<(Contour, Contour, bool)> = Vec::new();
|
|
for k in 0..a.len().max(b.len()) {
|
|
let (ca, cb) = (a.get(k), b.get(k));
|
|
let n = curves_for(ca.map_or(0, Contour::curves), cb.map_or(0, Contour::curves));
|
|
let point = |c: &Contour, from, to, closed| Contour { closed, pts: vec![place(c, from, to); 1 + 3 * n] };
|
|
match (ca, cb) {
|
|
(Some(x), Some(y)) => pairs.push((refine(x, n), refine(y, n), false)),
|
|
(Some(x), None) => pairs.push((refine(x, n), point(x, ba, bb, x.closed), true)),
|
|
(None, Some(y)) => pairs.push((point(y, bb, ba, y.closed), refine(y, n), true)),
|
|
(None, None) => {}
|
|
}
|
|
}
|
|
let mut best: Option<(Vec<Contour>, Vec<Contour>, f64)> = None;
|
|
for back in [false, true] {
|
|
let (mut xs, mut ys, mut cost) = (Vec::new(), Vec::new(), 0.0);
|
|
for (x, y, point) in &pairs {
|
|
if *point {
|
|
xs.push(x.clone());
|
|
ys.push(if back { Contour { closed: y.closed, pts: turn(&y.pts, 0, true) } } else { y.clone() });
|
|
} else {
|
|
let (mx, my, c) = match_pair(x, y, back);
|
|
xs.push(mx);
|
|
ys.push(my);
|
|
cost += c;
|
|
}
|
|
}
|
|
if best.as_ref().is_none_or(|b| cost < b.2) {
|
|
best = Some((xs, ys, cost));
|
|
}
|
|
}
|
|
best.map(|(x, y, _)| (x, y)).unwrap_or_default()
|
|
}
|
|
|
|
// --- whole geometries ----------------------------------------------------------------------------
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
struct Look {
|
|
fill: FillMode,
|
|
stroke: bool,
|
|
even_odd: bool,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct Part {
|
|
a: Option<Look>,
|
|
b: Option<Look>,
|
|
ca: Vec<Contour>,
|
|
cb: Vec<Contour>,
|
|
}
|
|
|
|
/// Two shape geometries brought to the same structure once, then blended per frame with
|
|
/// [`GeometryMorph::at`]. Sub-paths pair up in order; one without partner grows out of (or shrinks
|
|
/// into) a point. When a pair differs in fill mode, outline or fill rule, the two looks cross-fade
|
|
/// (see [`Fade`]).
|
|
#[derive(Clone, Debug)]
|
|
pub struct GeometryMorph {
|
|
parts: Vec<Part>,
|
|
text: (Rect, Rect),
|
|
}
|
|
|
|
fn look(s: &SubPath) -> Look {
|
|
Look { fill: s.fill, stroke: s.stroke, even_odd: s.even_odd }
|
|
}
|
|
|
|
/// How strongly a sub-path of a morphed geometry shows: its fill and its outline, 0..1.
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub struct Fade {
|
|
pub fill: f64,
|
|
pub stroke: f64,
|
|
}
|
|
|
|
/// The layers a pair of looks is drawn with at `t`, bottom first. A fill or an outline only one side
|
|
/// has fades out (or in). When both fill, the side with the even-odd rule lies opaque underneath and
|
|
/// the other fades over it, so a donut's hole fills smoothly; with the same rule both cover the same
|
|
/// area, so this is a plain cross-fade (shading of 3-D faces).
|
|
fn layers(a: Option<Look>, b: Option<Look>, t: f64) -> Vec<(Look, Fade)> {
|
|
let (a, b) = match (a, b) {
|
|
(Some(a), Some(b)) if a != b => (a, b),
|
|
(Some(x), _) | (None, Some(x)) => return vec![(x, Fade { fill: 1.0, stroke: 1.0 })],
|
|
(None, None) => return vec![],
|
|
};
|
|
let side = |on_a: bool, on_b: bool| match (on_a, on_b) {
|
|
(true, true) => 1.0,
|
|
(true, false) => 1.0 - t,
|
|
(false, true) => t,
|
|
(false, false) => 0.0,
|
|
};
|
|
let (stroke, line) = (a.stroke || b.stroke, side(a.stroke, b.stroke));
|
|
let (fa, fb) = (a.fill != FillMode::None, b.fill != FillMode::None);
|
|
if fa && fb {
|
|
let (under, over, alpha) = if a.even_odd || !b.even_odd { (a, b, t) } else { (b, a, 1.0 - t) };
|
|
vec![(Look { stroke, ..under }, Fade { fill: 1.0, stroke: line }), (Look { stroke: false, ..over }, Fade { fill: alpha, stroke: 0.0 })]
|
|
} else {
|
|
let filled = if fa { a } else { b };
|
|
vec![(Look { stroke, ..filled }, Fade { fill: side(fa, fb), stroke: line })]
|
|
}
|
|
}
|
|
|
|
impl GeometryMorph {
|
|
/// `a` and `b` each in their own shape-local space.
|
|
pub fn new(a: &Geometry, b: &Geometry) -> Self {
|
|
let ca: Vec<Vec<Contour>> = a.paths.iter().map(|s| contours(&s.path)).collect();
|
|
let cb: Vec<Vec<Contour>> = b.paths.iter().map(|s| contours(&s.path)).collect();
|
|
let ba = bounds(ca.iter().flatten().flat_map(|c| &c.pts));
|
|
let bb = bounds(cb.iter().flatten().flat_map(|c| &c.pts));
|
|
let mut parts = Vec::new();
|
|
for k in 0..a.paths.len().max(b.paths.len()) {
|
|
let (xa, xb) = (ca.get(k).map(Vec::as_slice).unwrap_or(&[]), cb.get(k).map(Vec::as_slice).unwrap_or(&[]));
|
|
let (pa, pb) = align(xa, xb, ba, bb);
|
|
parts.push(Part { a: a.paths.get(k).map(look), b: b.paths.get(k).map(look), ca: pa, cb: pb });
|
|
}
|
|
GeometryMorph { parts, text: (a.text_rect, b.text_rect) }
|
|
}
|
|
|
|
/// The geometry at `t` (0..1), with a [`Fade`] for each of its sub-paths. The points of `a` are
|
|
/// first scaled by `sa` and those of `b` by `sb`, to bring both into the current box.
|
|
pub fn at(&self, t: f64, sa: Vec2, sb: Vec2) -> (Geometry, Vec<Fade>) {
|
|
let t = if t.is_finite() { t.clamp(0.0, 1.0) } else { 0.0 };
|
|
let scale = |p: Point, s: Vec2| Point::new(p.x * s.x, p.y * s.y);
|
|
let (mut paths, mut fades) = (Vec::new(), Vec::new());
|
|
for part in &self.parts {
|
|
let cs: Vec<Contour> = part
|
|
.ca
|
|
.iter()
|
|
.zip(&part.cb)
|
|
.map(|(x, y)| Contour {
|
|
closed: x.closed && y.closed,
|
|
pts: x.pts.iter().zip(&y.pts).map(|(p, q)| scale(*p, sa).lerp(scale(*q, sb), t)).collect(),
|
|
})
|
|
.collect();
|
|
let path = to_path(&cs);
|
|
for (lk, fade) in layers(part.a, part.b, t) {
|
|
paths.push(SubPath { path: path.clone(), fill: lk.fill, stroke: lk.stroke, even_odd: lk.even_odd });
|
|
fades.push(fade);
|
|
}
|
|
}
|
|
let r = |r: Rect, s: Vec2| Rect::new(r.x0 * s.x, r.y0 * s.y, r.x1 * s.x, r.y1 * s.y);
|
|
let (ta, tb) = (r(self.text.0, sa), r(self.text.1, sb));
|
|
let text_rect = Rect::from_points(ta.origin().lerp(tb.origin(), t), Point::new(ta.x1, ta.y1).lerp(Point::new(tb.x1, tb.y1), t));
|
|
(Geometry { paths, text_rect, handles: vec![], sites: vec![] }, fades)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::preset::build;
|
|
use kurbo::Shape as _;
|
|
|
|
fn bbox(g: &Geometry) -> Rect {
|
|
g.outline().bounding_box()
|
|
}
|
|
|
|
fn near(a: Rect, b: Rect) -> bool {
|
|
(a.x0 - b.x0).abs() < 1e-6 && (a.y0 - b.y0).abs() < 1e-6 && (a.x1 - b.x1).abs() < 1e-6 && (a.y1 - b.y1).abs() < 1e-6
|
|
}
|
|
|
|
#[test]
|
|
fn contours_turn_lines_and_quads_into_cubics() {
|
|
let mut p = BezPath::new();
|
|
p.move_to((0.0, 0.0));
|
|
p.line_to((3.0, 0.0));
|
|
p.quad_to((3.0, 3.0), (0.0, 3.0));
|
|
p.close_path();
|
|
// After a close, drawing goes on from the start point.
|
|
p.line_to((5.0, 5.0));
|
|
p.move_to((9.0, 9.0));
|
|
let cs = contours(&p);
|
|
assert_eq!(cs.len(), 2, "{cs:?}");
|
|
assert!(cs[0].closed && !cs[1].closed);
|
|
// line, quad and the closing line.
|
|
assert_eq!(cs[0].curves(), 3);
|
|
assert_eq!(cs[0].pts[1], Point::new(1.0, 0.0));
|
|
assert_eq!(cs[0].pts.last(), cs[0].pts.first());
|
|
let end = Point::new(5.0, 5.0);
|
|
assert_eq!(cs[1].pts, vec![Point::ZERO, Point::ZERO.lerp(end, 1.0 / 3.0), Point::ZERO.lerp(end, 2.0 / 3.0), end]);
|
|
// The lone move_to at the end makes no contour, and the path comes back the same.
|
|
assert_eq!(contours(&to_path(&cs)), cs);
|
|
}
|
|
|
|
#[test]
|
|
fn refine_splits_the_longest_curves_and_keeps_the_shape() {
|
|
let c = Contour { closed: false, pts: vec![Point::ZERO, Point::new(1.0, 0.0), Point::new(2.0, 0.0), Point::new(3.0, 0.0)] };
|
|
let mut long = c.clone();
|
|
line_to(&mut long.pts, Point::new(3.0, 30.0));
|
|
let r = refine(&long, 5);
|
|
assert_eq!(r.curves(), 5);
|
|
// The short first side stays one curve, the long one gets the other four.
|
|
assert_eq!(r.pts[3], Point::new(3.0, 0.0));
|
|
assert_eq!(r.pts.last(), Some(&Point::new(3.0, 30.0)));
|
|
assert!(r.pts.iter().all(|p| (p.x - 3.0).abs() < 1e-9 || p.y == 0.0));
|
|
assert_eq!(refine(&c, 1), c);
|
|
assert_eq!(curves_for(3, 4), 12);
|
|
assert_eq!(curves_for(4, 4), 12);
|
|
// The common multiple 77 is too many: the larger count, doubled to reach the minimum.
|
|
assert_eq!(curves_for(7, 11), 22);
|
|
assert_eq!(curves_for(0, 0), 12);
|
|
}
|
|
|
|
#[test]
|
|
fn ellipse_turns_into_a_star_and_lands_exactly() {
|
|
let (a, b) = (build("ellipse", 100.0, 100.0, &[]).unwrap(), build("star5", 200.0, 100.0, &[]).unwrap());
|
|
let m = GeometryMorph::new(&a, &b);
|
|
let one = Vec2::new(1.0, 1.0);
|
|
assert!(near(bbox(&m.at(0.0, one, one).0), bbox(&a)));
|
|
assert!(near(bbox(&m.at(1.0, one, one).0), bbox(&b)));
|
|
let mid = m.at(0.5, one, one).0;
|
|
assert_eq!(mid.paths.len(), 1);
|
|
assert!(mid.paths[0].path.elements().iter().all(|e| e.end_point().is_none_or(|p| p.is_finite())));
|
|
// Non-finite progress is the start.
|
|
assert!(near(bbox(&m.at(f64::NAN, one, one).0), bbox(&a)));
|
|
}
|
|
|
|
#[test]
|
|
fn triangle_does_not_twist_into_a_circle() {
|
|
let (a, b) = (build("triangle", 100.0, 100.0, &[]).unwrap(), build("ellipse", 100.0, 100.0, &[]).unwrap());
|
|
let ca = contours(&a.paths[0].path);
|
|
let cb = contours(&b.paths[0].path);
|
|
let (x, y) = align(&ca, &cb, None, None);
|
|
// Every point travels less than the shapes are wide: no point crosses to the other side.
|
|
let far = x[0].pts.iter().zip(&y[0].pts).map(|(p, q)| p.distance(*q)).fold(0.0, f64::max);
|
|
assert!(far < 60.0, "{far}");
|
|
}
|
|
|
|
#[test]
|
|
fn extra_sub_paths_grow_out_of_a_point() {
|
|
let (a, b) = (build("rect", 100.0, 100.0, &[]).unwrap(), build("cube", 100.0, 100.0, &[]).unwrap());
|
|
assert!(b.paths.len() > 1);
|
|
let m = GeometryMorph::new(&a, &b);
|
|
let one = Vec2::new(1.0, 1.0);
|
|
let start = m.at(0.0, one, one).0;
|
|
assert_eq!(start.paths.len(), b.paths.len());
|
|
for sp in start.paths.iter().skip(1) {
|
|
let r = sp.path.bounding_box();
|
|
assert!(r.width() < 1e-9 && r.height() < 1e-9, "{r:?}");
|
|
}
|
|
// Looks switch at the midpoint: the cube's shaded faces show from there on.
|
|
assert_eq!(m.at(1.0, one, one).0.paths.iter().map(|s| s.fill).collect::<Vec<_>>(), b.paths.iter().map(|s| s.fill).collect::<Vec<_>>());
|
|
// And the other way round, the faces shrink away.
|
|
let back = GeometryMorph::new(&b, &a).at(1.0, one, one).0;
|
|
assert!(back.paths.iter().skip(1).all(|sp| sp.path.bounding_box().area() < 1e-9));
|
|
}
|
|
|
|
#[test]
|
|
fn differing_looks_cross_fade() {
|
|
let one = Vec2::new(1.0, 1.0);
|
|
let fades = |a: &Geometry, b: &Geometry, t: f64| {
|
|
let (g, f) = GeometryMorph::new(a, b).at(t, one, one);
|
|
g.paths.iter().zip(f).map(|(s, f)| (s.fill, s.even_odd, s.stroke, f.fill, f.stroke)).collect::<Vec<_>>()
|
|
};
|
|
// A filled rectangle into a line: the fill fades out, the outline stays.
|
|
let (r, line) = (build("rect", 100.0, 100.0, &[]).unwrap(), build("line", 100.0, 0.0, &[]).unwrap());
|
|
assert_eq!(fades(&r, &line, 0.25), [(FillMode::Norm, false, true, 0.75, 1.0)]);
|
|
assert_eq!(fades(&line, &r, 0.25), [(FillMode::Norm, false, true, 0.25, 1.0)]);
|
|
// A donut into a circle: the donut (even-odd) lies underneath, the circle fades in over its hole.
|
|
let (d, e) = (build("donut", 100.0, 100.0, &[]).unwrap(), build("ellipse", 100.0, 100.0, &[]).unwrap());
|
|
assert!(d.paths[0].even_odd && !e.paths[0].even_odd);
|
|
assert_eq!(fades(&d, &e, 0.25), [(FillMode::Norm, true, true, 1.0, 1.0), (FillMode::Norm, false, false, 0.25, 0.0)]);
|
|
assert_eq!(fades(&e, &d, 0.25), [(FillMode::Norm, true, true, 1.0, 1.0), (FillMode::Norm, false, false, 0.75, 0.0)]);
|
|
// Same looks: one layer, fully there.
|
|
assert_eq!(fades(&e, &r, 0.5), [(FillMode::Norm, false, true, 1.0, 1.0)]);
|
|
}
|
|
|
|
#[test]
|
|
fn scales_bring_both_sides_into_the_current_box() {
|
|
let (a, b) = (build("rect", 10.0, 10.0, &[]).unwrap(), build("ellipse", 40.0, 20.0, &[]).unwrap());
|
|
let m = GeometryMorph::new(&a, &b);
|
|
// Current box 20 x 20: a scaled up twice, b to half the width.
|
|
let g = m.at(0.0, Vec2::new(2.0, 2.0), Vec2::new(0.5, 1.0)).0;
|
|
assert!(near(bbox(&g), Rect::new(0.0, 0.0, 20.0, 20.0)));
|
|
assert!(near(g.text_rect, Rect::new(a.text_rect.x0 * 2.0, a.text_rect.y0 * 2.0, a.text_rect.x1 * 2.0, a.text_rect.y1 * 2.0)));
|
|
let g = m.at(1.0, Vec2::new(2.0, 2.0), Vec2::new(0.5, 1.0)).0;
|
|
assert!(near(bbox(&g), Rect::new(0.0, 0.0, 20.0, 20.0)));
|
|
}
|
|
|
|
#[test]
|
|
fn empty_and_degenerate_geometries_do_not_crash() {
|
|
let empty = Geometry { paths: vec![], text_rect: Rect::ZERO, handles: vec![], sites: vec![] };
|
|
let r = build("rect", 10.0, 10.0, &[]).unwrap();
|
|
let line = build("line", 10.0, 0.0, &[]).unwrap();
|
|
let mut nan = BezPath::new();
|
|
nan.move_to((f64::NAN, 0.0));
|
|
nan.line_to((1.0, 1.0));
|
|
let bad = Geometry { paths: vec![SubPath { path: nan, fill: FillMode::Norm, stroke: true, even_odd: false }], ..empty.clone() };
|
|
for (x, y) in [(&empty, &empty), (&empty, &r), (&r, &empty), (&r, &line), (&line, &r), (&bad, &r), (&r, &bad)] {
|
|
for t in [0.0, 0.5, 1.0, f64::INFINITY] {
|
|
let g = GeometryMorph::new(x, y).at(t, Vec2::new(1.0, 1.0), Vec2::new(0.0, 1e300)).0;
|
|
// At most two layers per sub-path pair.
|
|
assert!(g.paths.len() <= 2 * x.paths.len().max(y.paths.len()));
|
|
}
|
|
}
|
|
// A rectangle into a line: the line is open, so the morph ends open.
|
|
let g = GeometryMorph::new(&r, &line).at(1.0, Vec2::new(1.0, 1.0), Vec2::new(1.0, 1.0)).0;
|
|
assert!(!g.paths[0].path.elements().iter().any(|e| matches!(e, PathEl::ClosePath)));
|
|
}
|
|
|
|
#[test]
|
|
fn long_contours_sample_their_start_points() {
|
|
// A polygon with many corners still aligns (and quickly): the start search is capped.
|
|
let mut p = BezPath::new();
|
|
for k in 0..2000 {
|
|
let a = k as f64 / 2000.0 * std::f64::consts::TAU;
|
|
let q = (50.0 + 50.0 * a.cos(), 50.0 + 50.0 * a.sin());
|
|
if k == 0 { p.move_to(q) } else { p.line_to(q) }
|
|
}
|
|
p.close_path();
|
|
let many = contours(&p);
|
|
let e = contours(&build("ellipse", 100.0, 100.0, &[]).unwrap().paths[0].path);
|
|
let (x, y) = align(&many, &e, None, None);
|
|
assert_eq!(x[0].curves(), y[0].curves());
|
|
assert_eq!(x[0].curves(), 2000);
|
|
}
|
|
}
|