Files
effectcraft/crates/effects/src/puppet/tests.rs
T
Brandon ThomasandClaude Opus 5.5 d6f6a10757 M13.1/M13.2: paint (Brush, Clone Stamp, Eraser) and puppet pins
Paint: non-destructive Paint effect with Brush/Clone/Eraser stroke groups
(Path, Stroke Options, Transform, Duration spans, Write On End keys),
dab rasterizer (diameter/angle/roundness/hardness/spacing/flow/opacity,
pressure dynamics, modes, channels), eraser modes, clone from layer/time,
cache keys include visible strokes. paint.stroke/options/brushPreset/
setCloneSource/removeStroke/presets. Layer panel with paint tools, Paint
and Brushes panels.

Puppet: Puppet effect with meshes and Position/Advanced/Bend/Starch/Overlap
pins; alpha contour -> expansion (exact EDT) -> simplified outline ->
Delaunay with constraint recovery; ARAP (Igarashi 2005) two-step solve with
CG; anti-aliased texture-mapped rendering with overlap depth. puppet.addPin/
movePin/setPin/removePin/mesh/info. Puppet tools in the viewer with mesh
overlay and header options.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 09:12:10 -04:00

309 lines
12 KiB
Rust

use super::mesh::*;
use super::*;
use crate::{EffectEnv, flatten_params, instantiate};
fn disc_alpha(w: usize, h: usize, c: [f64; 2], r: f64) -> Vec<f32> {
let mut a = vec![0.0; w * h];
for y in 0..h {
for x in 0..w {
let d = ((x as f64 + 0.5 - c[0]).powi(2) + (y as f64 + 0.5 - c[1]).powi(2)).sqrt();
a[y * w + x] = if d <= r { 1.0 } else { 0.0 };
}
}
a
}
fn check_valid(m: &Mesh) {
assert!(!m.tris.is_empty());
for t in &m.tris {
let a = cross(m.verts[t[0]], m.verts[t[1]], m.verts[t[2]]);
assert!(a > 0.0, "flipped or degenerate triangle {t:?} area {a}");
}
let tri_area: f64 = m.tris.iter().map(|t| cross(m.verts[t[0]], m.verts[t[1]], m.verts[t[2]]) * 0.5).sum();
let poly_area = signed_area(&m.outline).abs();
assert!((tri_area - poly_area).abs() < 1e-6 * poly_area.max(1.0), "triangles {tri_area} vs outline {poly_area}");
}
fn covered(m: &Mesh, p: [f64; 2]) -> bool {
m.tris.iter().any(|t| {
let (a, b, c) = (m.verts[t[0]], m.verts[t[1]], m.verts[t[2]]);
cross(a, b, p) >= -1e-9 && cross(b, c, p) >= -1e-9 && cross(c, a, p) >= -1e-9
})
}
#[test]
fn distance_transform_matches_brute_force() {
let (w, h) = (13, 9);
let src: Vec<bool> = (0..w * h).map(|i| i % 17 == 3 || i == 50).collect();
let d = distance_sq(w, h, &src);
for y in 0..h {
for x in 0..w {
let mut best = f64::MAX;
for yy in 0..h {
for xx in 0..w {
if src[yy * w + xx] {
best = best.min(((x as f64 - xx as f64).powi(2)) + (y as f64 - yy as f64).powi(2));
}
}
}
assert_eq!(d[y * w + x], best, "({x},{y})");
}
}
}
#[test]
fn triangulation_is_valid_and_covers_the_alpha() {
let (w, h) = (120, 100);
let alpha = disc_alpha(w, h, [60.0, 50.0], 38.0);
let outline = outline(&alpha, w, h, 1.0, [0.0; 2], [60.0, 50.0], 3.0);
let m = triangulate(&outline, &MeshOpts::default());
check_valid(&m);
assert!(m.tris.len() > 150 && m.tris.len() < 800, "{} triangles", m.tris.len());
for y in 0..h {
for x in 0..w {
if alpha[y * w + x] > 0.0 {
assert!(covered(&m, [x as f64 + 0.5, y as f64 + 0.5]), "alpha pixel ({x},{y}) not covered");
}
}
}
// Density controls the triangle count.
let fine = triangulate(&outline, &MeshOpts { density: 100.0, ..MeshOpts::default() });
check_valid(&fine);
assert!(fine.tris.len() > m.tris.len() * 2);
}
#[test]
fn concave_outline_keeps_its_edges() {
// A U shape (concave) and an L shape.
let (w, h) = (100, 100);
let mut alpha = vec![0.0f32; w * h];
for y in 10..90 {
for x in 10..90 {
let notch = (35..65).contains(&x) && y < 70;
alpha[y * w + x] = if notch { 0.0 } else { 1.0 };
}
}
let o = outline(&alpha, w, h, 1.0, [0.0; 2], [20.0, 50.0], 0.0);
let m = triangulate(&o, &MeshOpts { triangles: 120.0, ..Default::default() });
check_valid(&m);
// Nothing in the notch.
assert!(!covered(&m, [50.0, 30.0]));
for (x, y) in [(15.0, 15.0), (85.0, 15.0), (50.0, 80.0), (12.0, 88.0)] {
assert!(covered(&m, [x, y]), "({x},{y})");
}
}
#[test]
fn expansion_grows_the_outline() {
let (w, h) = (80, 80);
let alpha = disc_alpha(w, h, [40.0, 40.0], 20.0);
let a0 = signed_area(&outline(&alpha, w, h, 1.0, [0.0; 2], [40.0, 40.0], 0.0)).abs();
let a5 = signed_area(&outline(&alpha, w, h, 1.0, [0.0; 2], [40.0, 40.0], 5.0)).abs();
let am = signed_area(&outline(&alpha, w, h, 1.0, [0.0; 2], [40.0, 40.0], -5.0)).abs();
let pi = std::f64::consts::PI;
assert!((a0 - pi * 400.0).abs() < 60.0, "{a0}");
assert!((a5 - pi * 625.0).abs() < 90.0, "{a5}");
assert!((am - pi * 225.0).abs() < 60.0, "{am}");
}
fn rect_mesh(w: f64, h: f64, tris: f64) -> Mesh {
triangulate(&[[0.0, 0.0], [w, 0.0], [w, h], [0.0, h]], &MeshOpts { triangles: tris, density: 50.0, expansion: 0.0 })
}
fn pin(kind: PinKind, rest: [f64; 2], pos: [f64; 2]) -> Pin {
Pin { kind, uid: 0, rest, position: pos, scale: 1.0, rotation: 0.0, amount: 50.0, extent: 15.0, in_front: 50.0 }
}
#[test]
fn arap_identity_with_pins_at_rest() {
let m = rect_mesh(100.0, 60.0, 200.0);
check_valid(&m);
let pins = [pin(PinKind::Position, [0.0, 0.0], [0.0, 0.0]), pin(PinKind::Position, [100.0, 60.0], [100.0, 60.0])];
let d = solve(&m, &pins, 2);
for (a, b) in d.iter().zip(&m.verts) {
assert!((a[0] - b[0]).abs() < 1e-7 && (a[1] - b[1]).abs() < 1e-7, "{a:?} vs {b:?}");
}
}
#[test]
fn arap_single_pin_translates_rigidly() {
let m = rect_mesh(100.0, 60.0, 200.0);
let d = solve(&m, &[pin(PinKind::Position, [50.0, 30.0], [70.0, 15.0])], 2);
let v = m.verts[nearest(&m.verts, [50.0, 30.0]).unwrap()];
let t = [70.0 - 50.0 + (v[0] - 50.0) * 0.0, 15.0 - 30.0];
for (a, b) in d.iter().zip(&m.verts) {
assert!((a[0] - b[0] - t[0]).abs() < 1e-7 && (a[1] - b[1] - t[1]).abs() < 1e-7, "{a:?} vs {b:?}");
}
}
#[test]
fn arap_two_pins_rotate_rigidly() {
let m = rect_mesh(100.0, 40.0, 200.0);
let (a, b) = (m.verts[nearest(&m.verts, [0.0, 20.0]).unwrap()], m.verts[nearest(&m.verts, [100.0, 20.0]).unwrap()]);
let c = [(a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0];
let ang = 30f64.to_radians();
let rot = |p: [f64; 2]| {
let (s, co) = ang.sin_cos();
let d = [p[0] - c[0], p[1] - c[1]];
[c[0] + d[0] * co - d[1] * s, c[1] + d[0] * s + d[1] * co]
};
let pins = [pin(PinKind::Position, a, rot(a)), pin(PinKind::Position, b, rot(b))];
let d = solve(&m, &pins, 0);
for (p, r) in d.iter().zip(&m.verts) {
let e = rot(*r);
assert!((p[0] - e[0]).abs() < 1e-3 && (p[1] - e[1]).abs() < 1e-3, "{p:?} vs {e:?}");
}
}
fn distortion(m: &Mesh, d: &[[f64; 2]], near: [f64; 2], radius: f64) -> f64 {
let mut s = 0.0;
for t in &m.tris {
let c = [(m.verts[t[0]][0] + m.verts[t[1]][0] + m.verts[t[2]][0]) / 3.0, (m.verts[t[0]][1] + m.verts[t[1]][1] + m.verts[t[2]][1]) / 3.0];
if (c[0] - near[0]).hypot(c[1] - near[1]) > radius {
continue;
}
for (i, j) in [(t[0], t[1]), (t[1], t[2]), (t[2], t[0])] {
let l0 = (m.verts[i][0] - m.verts[j][0]).hypot(m.verts[i][1] - m.verts[j][1]);
let l1 = (d[i][0] - d[j][0]).hypot(d[i][1] - d[j][1]);
s += (l1 / l0 - 1.0).powi(2);
}
}
s
}
#[test]
fn starch_reduces_distortion() {
let m = rect_mesh(200.0, 40.0, 300.0);
// Squash the bar: both ends pushed inwards and one end lifted.
let base = vec![pin(PinKind::Position, [0.0, 20.0], [30.0, 20.0]), pin(PinKind::Position, [200.0, 20.0], [160.0, 60.0])];
let plain = solve(&m, &base, 2);
let mut st = base.clone();
st.push(Pin { amount: 100.0, extent: 30.0, ..pin(PinKind::Starch, [100.0, 20.0], [100.0, 20.0]) });
let starched = solve(&m, &st, 2);
let (a, b) = (distortion(&m, &plain, [100.0, 20.0], 25.0), distortion(&m, &starched, [100.0, 20.0], 25.0));
assert!(b < a * 0.5, "starch {b} vs plain {a}");
}
#[test]
fn bend_pin_rotates_around_it() {
let m = rect_mesh(100.0, 40.0, 200.0);
let mut bend = pin(PinKind::Bend, [100.0, 20.0], [100.0, 20.0]);
bend.rotation = 45.0;
let d = solve(&m, &[pin(PinKind::Position, [0.0, 20.0], [0.0, 20.0]), bend], 2);
// The far end turned downwards (positive rotation in y-down layer space).
let v = nearest(&m.verts, [100.0, 40.0]).unwrap();
let u = nearest(&m.verts, [100.0, 0.0]).unwrap();
assert!(d[v][0] < d[u][0] - 5.0, "bottom {:?} top {:?}", d[v], d[u]);
}
#[test]
fn overlap_pins_set_depth() {
let m = rect_mesh(100.0, 40.0, 100.0);
let mut o = pin(PinKind::Overlap, [20.0, 20.0], [20.0, 20.0]);
o.in_front = 80.0;
o.extent = 15.0;
let d = depths(&m, &[o]);
assert!(d.contains(&80.0));
assert!(d.contains(&0.0));
}
fn puppet_fx(pins: &[(PinKind, [f64; 2], [f64; 2])]) -> PropGroup {
let mut next = 5000;
let mut ids = Ids(&mut next);
let mut fx = instantiate(crate::find(ID).unwrap(), &mut ids, "Puppet", [64.0, 64.0]);
let mut mesh = mesh_group(&mut ids, "Mesh 1", pins.first().map(|p| p.1).unwrap_or([32.0; 2]), &MeshOpts::default());
for (k, (kind, rest, pos)) in pins.iter().enumerate() {
let mut g = pin_group(&mut ids, &format!("Puppet Pin {}", k + 1), *kind, *rest);
if let Some(p) = g.get_mut("position") {
p.value = Value::Vec2(*pos);
}
mesh.sub_mut("deform").unwrap().children.push(g.into());
}
fx.children.push(mesh.into());
fx
}
fn run(fx: &PropGroup, img: Image) -> Buf {
let params = flatten_params(fx, &mut |p| p.value.clone());
let ctx =
EffectCtx { params: &params, time: 0.0, layer_size: [img.width as f64, img.height as f64], seed: 1, adjustment: false, env: EffectEnv::default() };
crate::apply(crate::find(ID).unwrap(), &ctx, Buf { img, offset: [0.0; 2], scale: 1.0 })
}
fn test_image() -> Image {
let mut img = Image::new(64, 64);
for y in 0..64u32 {
for x in 0..64u32 {
if (12..52).contains(&x) && (16..48).contains(&y) {
img.set(x, y, [x as f32 / 64.0, y as f32 / 64.0, ((x + y) % 3) as f32 / 3.0, 1.0]);
}
}
}
img
}
/// Output pixel at layer pixel (x, y).
fn at(b: &Buf, x: i64, y: i64) -> [f32; 4] {
b.img.get(x + b.offset[0] as i64, y + b.offset[1] as i64)
}
#[test]
fn render_identity_and_translation() {
let img = test_image();
let id = run(&puppet_fx(&[(PinKind::Position, [30.0, 30.0], [30.0, 30.0])]), img.clone());
for y in 17..47 {
for x in 13..51 {
let (o, e) = (at(&id, x, y), img.get(x, y));
assert!((0..4).all(|c| (o[c] - e[c]).abs() < 1e-5), "({x},{y}) {o:?} vs {e:?}");
}
}
let moved = run(&puppet_fx(&[(PinKind::Position, [30.0, 30.0], [40.0, 35.0])]), img.clone());
for y in 17..47 {
for x in 13..51 {
let o = at(&moved, x + 10, y + 5);
let e = img.get(x, y);
for c in 0..4 {
assert!((o[c] - e[c]).abs() < 1e-4, "({x},{y}) {o:?} vs {e:?}");
}
}
}
// Outside the mesh: nothing.
assert_eq!(at(&moved, 2, 2), [0.0; 4]);
}
#[test]
fn render_is_deterministic_and_antialiased() {
let img = test_image();
let fx = puppet_fx(&[(PinKind::Position, [14.0, 30.0], [14.0, 30.0]), (PinKind::Position, [50.0, 30.0], [45.0, 10.0])]);
let a = run(&fx, img.clone());
let b = run(&fx, img);
assert_eq!(a.img, b.img);
assert_eq!(a.offset, b.offset);
assert!(a.img.data.iter().any(|p| p[3] > 0.05 && p[3] < 0.95), "expected soft edges");
assert!(a.img.data.iter().all(|p| p[3] <= 1.0001 && p.iter().all(|c| c.is_finite())));
}
#[test]
fn unmap_inverts_the_deformation() {
let m = rect_mesh(100.0, 40.0, 150.0);
let pins = [pin(PinKind::Position, [0.0, 20.0], [10.0, 30.0]), pin(PinKind::Position, [100.0, 20.0], [90.0, 0.0])];
let d = solve(&m, &pins, 1);
let q = unmap(&m, &d, d[5]);
assert!((q[0] - m.verts[5][0]).abs() < 1e-6 && (q[1] - m.verts[5][1]).abs() < 1e-6);
}
#[test]
fn groups_round_trip_serde() {
let fx = puppet_fx(&[(PinKind::Position, [1.0, 2.0], [3.0, 4.0]), (PinKind::Starch, [5.0, 5.0], [5.0, 5.0])]);
let j = serde_json::to_string(&fx).unwrap();
let back: PropGroup = serde_json::from_str(&j).unwrap();
assert_eq!(back, fx);
assert_eq!(pin_count(&back), 2);
let params = flatten_params(&back, &mut |p| p.value.clone());
let m = parse(&params);
assert_eq!(m.len(), 1);
assert_eq!(m[0].pins.len(), 2);
assert_eq!(m[0].pins[1].kind, PinKind::Starch);
assert_eq!(m[0].pins[0].position, [3.0, 4.0]);
}