Files
FredApps 31658546a8 fix(codecs): build the cutover against craft-libs d6cd7836d
- Test files whose image→craft-image-codecs rewrites didn't compile against
  main's newer tests go back to main's versions (engine fileio/tests.rs,
  tests_tiffbmp.rs, tests/menucmds.rs, eps tests.rs); they still use the image
  crate, which keeps its format features.
- craft_jxl::encode, craft_image_codecs::encode and Image::icc at d6cd7836d.
- jp2read and pdf export pass DecodeOptions, not Limits.
- EPS DCTDecode: grey JPEGs no longer use the image after moving it, and keep
  main's one-channel output.
- svg keeps its direct usvg dependency for main's image href code; pdf keeps
  jpeg-encoder for CMYK JPEGs.
- clippy -D warnings and rustfmt clean.
2026-11-15 18:05:45 +01:00

773 lines
37 KiB
Rust

//! Drawing again only what an edit changed gives the pixels of drawing it all again.
use crate::*;
use vectorcraft_color::{Color, Paint};
use vectorcraft_doc::Appearance;
use vectorcraft_geom::{Anchor, PathData, Point, SubPath, Vec2, shapes};
const W: u32 = 160;
const H: u32 = 120;
/// A view that doesn't line the art up with the pixels, so the edges are anti-aliased.
fn view() -> Affine {
Affine::translate((3.3, 2.7)) * Affine::scale(1.37)
}
fn rect(d: &mut Document, r: Rect, fill: Color) -> Node {
let id = d.alloc_id();
Node::path(id, shapes::rectangle(r), Appearance::basic(Paint::solid(fill), Paint::solid(Color::BLACK), 2.0))
}
fn shadow() -> vectorcraft_doc::Effect {
vectorcraft_doc::Effect {
id: "stylize.dropShadow".into(),
params: serde_json::json!({"x": 6.0, "y": 6.0, "blur": 4.0, "opacity": 75.0}),
visible: true,
}
}
/// A layer with a rectangle, a group at half opacity holding two, a clip group, and one with a
/// drop shadow; the ids of the loose rectangle, a member of each group, and the shadowed one.
fn document() -> (Document, [NodeId; 5]) {
let mut d = Document::new(110.0, 80.0);
let l = d.layers[0].id;
let loose = rect(&mut d, Rect::new(5.0, 5.0, 25.0, 20.0), Color::rgb(1.0, 0.0, 0.0));
let loose = d.insert(Some(l), 0, loose).unwrap();
let (a, b) = (
rect(&mut d, Rect::new(30.0, 5.0, 50.0, 25.0), Color::rgb(0.0, 0.6, 0.0)),
rect(&mut d, Rect::new(40.0, 15.0, 60.0, 35.0), Color::rgb(0.0, 0.0, 1.0)),
);
let mut group = Node::new(d.alloc_id(), NodeKind::Group { children: vec![Arc::new(a), Arc::new(b)], clip: false });
group.opacity = 0.5;
let member = group.children().unwrap()[1].id;
d.insert(Some(l), 1, group).unwrap();
let (mask, art) =
(rect(&mut d, Rect::new(5.0, 40.0, 30.0, 60.0), Color::WHITE), rect(&mut d, Rect::new(0.0, 45.0, 40.0, 55.0), Color::rgb(0.8, 0.4, 0.0)));
let clipped = art.id;
let clip = Node::new(d.alloc_id(), NodeKind::Group { children: vec![Arc::new(mask), Arc::new(art)], clip: true });
d.insert(Some(l), 2, clip).unwrap();
let mut shadowed = rect(&mut d, Rect::new(60.0, 45.0, 80.0, 60.0), Color::rgb(0.9, 0.9, 0.2));
shadowed.appearance.effects.push(shadow());
let shadowed = d.insert(Some(l), 3, shadowed).unwrap();
let other = rect(&mut d, Rect::new(85.0, 10.0, 105.0, 30.0), Color::rgb(0.5, 0.0, 0.5));
let other = d.insert(Some(l), 4, other).unwrap();
(d, [loose, member, clipped, shadowed, other])
}
/// Draws `new` again only where it changed from `old`, over `old` drawn whole, and checks that
/// this is `new` drawn whole; returns what changed. Measured afresh ([`changed`]) and by the
/// renderer that drew `old`, which then draws the part ([`Renderer::changed`]): both must hold.
fn redraw(old: &Document, new: &Document) -> Changed {
let opts = RenderOptions::default();
let after = Renderer::new().render(new, W, H, view(), &opts);
let change = changed(old, new);
let mut fresh = Renderer::new();
let before = fresh.render(old, W, H, view(), &opts);
patched(&mut fresh, &before, new, change, &after, &opts);
let mut r = Renderer::new();
let before = r.render(old, W, H, view(), &opts);
let measured = r.changed(old, new, &opts);
patched(&mut r, &before, new, measured, &after, &opts);
change
}
/// `before` with `new` drawn again by `r` with `opts` only where `change` says, checked against
/// `after`.
fn patched(r: &mut Renderer, before: &Rendered, new: &Document, change: Changed, after: &Rendered, opts: &RenderOptions) {
let mut patched = Rendered { width: W, height: H, pixels: before.pixels.clone() };
match change {
Changed::Everything => patched.pixels = after.pixels.clone(),
Changed::Nothing => {}
Changed::Area(area) => {
if let Some([x0, y0, x1, y1]) = view_pixels(area, view(), W, H) {
let part = r.render(new, x1 - x0, y1 - y0, Affine::translate((-f64::from(x0), -f64::from(y0))) * view(), opts);
for y in 0..y1 - y0 {
let (from, to) = ((y * (x1 - x0) * 4) as usize, (((y0 + y) * W + x0) * 4) as usize);
let n = ((x1 - x0) * 4) as usize;
patched.pixels[to..to + n].copy_from_slice(&part.pixels[from..from + n]);
}
}
}
}
assert!(patched.pixels == after.pixels, "{change:?}: drawn again only there, it differs from drawing it all");
}
fn area(c: Changed) -> Rect {
match c {
Changed::Area(a) => a,
other => panic!("an area: {other:?}"),
}
}
#[test]
fn moving_an_object_changes_where_it_was_and_is() {
let (old, [loose, ..]) = document();
let mut new = old.clone();
new.node_mut(loose).unwrap().transform(Affine::translate((7.0, 3.0)), false);
let a = area(redraw(&old, &new));
assert!(a.contains(Point::new(6.0, 6.0)) && a.contains(Point::new(31.0, 22.0)), "before and after: {a:?}");
assert!(a.x1 < 35.0, "not the objects beside it: {a:?}");
}
#[test]
fn recolouring_a_member_of_a_translucent_group_changes_only_the_member() {
let (old, [_, member, ..]) = document();
let mut new = old.clone();
new.node_mut(member).unwrap().appearance.fill_mut().unwrap().paint = Paint::solid(Color::rgb(1.0, 0.5, 0.0));
let a = area(redraw(&old, &new));
assert!(a.x0 > 35.0, "not the group's other member: {a:?}");
}
#[test]
fn moving_clipped_art_changes_its_whole_clip_group() {
let (old, [_, _, clipped, ..]) = document();
let mut new = old.clone();
new.node_mut(clipped).unwrap().transform(Affine::translate((0.0, 4.0)), false);
redraw(&old, &new);
}
#[test]
fn moving_a_shadowed_object_changes_where_its_shadow_falls() {
let (old, [.., shadowed, _]) = document();
let mut new = old.clone();
new.node_mut(shadowed).unwrap().transform(Affine::translate((-5.0, 5.0)), false);
let a = area(redraw(&old, &new));
assert!(a.x1 > 86.0 && a.y1 > 70.0, "the shadow, before and after: {a:?}");
}
#[test]
fn adding_removing_and_restacking_change_those_objects() {
let (old, [loose, _, _, _, other]) = document();
let mut added = old.clone();
let n = rect(&mut added, Rect::new(70.0, 5.0, 90.0, 15.0), Color::BLACK);
let l = added.layers[0].id;
added.insert(Some(l), 5, n).unwrap();
redraw(&old, &added);
let mut removed = old.clone();
removed.remove(loose).unwrap();
redraw(&old, &removed);
let mut restacked = old.clone();
let n = restacked.remove(other).unwrap();
restacked.insert(Some(l), 0, (*n).clone()).unwrap();
redraw(&old, &restacked);
}
/// A blur too wide for a raster of all of it is cropped to the frame. A part of the frame drawn
/// again, during a drag too, draws it from that raster: the same pixels, and no preview at the
/// drag's lower resolution.
#[test]
fn a_part_of_a_frame_draws_a_cropped_blur_from_the_frames_raster() {
let (mut d, _) = document();
let mut back = rect(&mut d, Rect::new(0.0, 0.0, 110.0, 80.0), Color::rgb(0.1, 0.3, 0.9));
back.appearance.effects.push(vectorcraft_doc::Effect { id: "blur.gaussian".into(), params: serde_json::json!({"radius": 500.0}), visible: true });
let l = d.layers[0].id;
d.insert(Some(l), 0, back).unwrap();
let view = Affine::scale(2.0) * Affine::translate((-20.0, -15.0));
let mut r = Renderer::new();
let whole = r.render(&d, W, H, view, &RenderOptions::default());
let [x0, y0, x1, y1] = [40, 30, 100, 80];
let dragging = RenderOptions { interacting: true, dragging: true, ..Default::default() };
let part = r.render(&d, x1 - x0, y1 - y0, Affine::translate((-f64::from(x0), -f64::from(y0))) * view, &dragging);
assert_eq!(r.stats.previewed, 0, "drawn from the frame's raster");
for y in 0..y1 - y0 {
for x in 0..x1 - x0 {
assert_eq!(part.pixel(x, y), whole.pixel(x0 + x, y0 + y), "at {x}, {y}");
}
}
}
/// Type on a path whose path a script reshapes: its letters stand above the path and run past
/// where it ends, and they change where they were and where they are, outside the path's box.
#[test]
fn reshaping_the_path_of_type_on_a_path_changes_where_its_letters_were_and_are() {
let mut old = Document::new(110.0, 80.0);
let l = old.layers[0].id;
let on = |y: f64| {
let mut t = vectorcraft_doc::text::TextObject::point(
Point::ZERO,
"Text along a path",
vectorcraft_doc::text::CharStyle { size: 14.0, ..Default::default() },
);
let line = kurbo::Line::new((10.0, 60.0), (90.0, y)).to_path(0.1);
t.kind = vectorcraft_doc::TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&line), start: 0.0, end: None };
t.xf = Affine::IDENTITY;
// The engine lays out type that changed ([`vectorcraft_doc::TextObject::cached_bounds`]).
t.cached_bounds = Some(vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).bounds);
t
};
let text = old.insert(Some(l), 0, Node::new(NodeId(0), NodeKind::Text(Box::new(on(55.0))))).unwrap();
let mut new = old.clone();
if let Some(NodeKind::Text(t)) = new.node_mut(text).map(|n| &mut n.kind) {
**t = on(25.0);
}
redraw(&old, &new);
}
/// Stroked type with sharp corners: the miter spikes of its characters' strokes reach past half
/// the weight, and change where they were and where they are.
#[test]
fn moving_type_with_mitred_strokes_changes_where_its_spikes_reach() {
let mut old = Document::new(110.0, 80.0);
let l = old.layers[0].id;
let style = vectorcraft_doc::text::CharStyle {
size: 30.0,
stroke: Paint::solid(Color::BLACK),
stroke_width: 10.0,
stroke_join: vectorcraft_doc::LineJoin::Miter,
stroke_miter_limit: 10.0,
..Default::default()
};
let mut t = vectorcraft_doc::text::TextObject::point(Point::new(10.0, 50.0), "VAWV", style);
t.cached_bounds = Some(vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).bounds);
let text = old.insert(Some(l), 0, Node::new(NodeId(0), NodeKind::Text(Box::new(t)))).unwrap();
let mut new = old.clone();
new.node_mut(text).unwrap().transform(Affine::translate((9.0, 7.0)), false);
redraw(&old, &new);
}
#[test]
fn an_unchanged_document_changes_nothing_and_a_new_symbol_everything() {
let (old, _) = document();
assert_eq!(redraw(&old, &old.clone()), Changed::Nothing);
let mut new = old.clone();
let art = Arc::new(rect(&mut new, Rect::new(0.0, 0.0, 5.0, 5.0), Color::BLACK));
new.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Dot".into(), art });
assert_eq!(redraw(&old, &new), Changed::Everything);
}
/// While a pattern is edited its art also draws in the copies round it: an edit of it changes
/// everything.
#[test]
fn an_edit_while_a_pattern_is_edited_changes_everything() {
let (mut old, [loose, ..]) = document();
let l = old.layers[0].id;
old.pattern_edit = Some(vectorcraft_doc::PatternEdit { pattern: "Tile".into(), layer: l, original: None });
let mut new = old.clone();
new.node_mut(loose).unwrap().transform(Affine::translate((7.0, 3.0)), false);
assert_eq!(changed(&old, &new), Changed::Everything);
}
/// Type stretched more on one axis than its area grows: its characters' strokes stretch with it.
#[test]
fn moving_stretched_type_changes_where_its_stretched_strokes_reach() {
let mut old = Document::new(110.0, 80.0);
let l = old.layers[0].id;
let style = vectorcraft_doc::text::CharStyle {
size: 4.0,
stroke: Paint::solid(Color::BLACK),
stroke_width: 1.0,
stroke_join: vectorcraft_doc::LineJoin::Miter,
stroke_miter_limit: 10.0,
..Default::default()
};
let mut t = vectorcraft_doc::text::TextObject::point(Point::ZERO, "VAWV", style);
t.cached_bounds = Some(vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).bounds);
// Its area stays, so its scale factor is 1, while it grows ten times as wide.
t.xf = Affine::translate((10.0, 40.0)) * Affine::scale_non_uniform(10.0, 0.1);
let text = old.insert(Some(l), 0, Node::new(NodeId(0), NodeKind::Text(Box::new(t)))).unwrap();
let mut new = old.clone();
new.node_mut(text).unwrap().transform(Affine::translate((9.0, 7.0)), false);
area(redraw(&old, &new));
}
/// `n` anchors round an ellipse at (55, 40) with radii `rx` and `ry` and a ripple, every third a
/// corner and the others smooth with handles along the ellipse.
fn wavy(n: usize, rx: f64, ry: f64) -> SubPath {
let anchors = (0..n)
.map(|i| {
let t = i as f64 / n as f64 * std::f64::consts::TAU;
let k = 1.0 + 0.06 * (t * 12.0).sin();
let p = Point::new(55.0 + rx * k * t.cos(), 40.0 + ry * k * t.sin());
if i % 3 == 0 {
return Anchor::corner(p);
}
let along = Vec2::new(-rx * t.sin(), ry * t.cos()) * (0.4 / n as f64);
Anchor { h_in: p - along, h_out: p + along, ..Anchor::corner(p) }
})
.collect();
SubPath::new(anchors, true)
}
/// The seven-pointed star {7/3} round (55, 40), each edge split by 39 anchors on it: its edges
/// cross, so parts of it are covered more than once.
fn star() -> SubPath {
let tip = |i: usize| {
let t = (i * 3 % 7) as f64 / 7.0 * std::f64::consts::TAU;
Point::new(55.0 + 45.0 * t.sin(), 40.0 - 35.0 * t.cos())
};
let anchors = (0..7).flat_map(|i| (0..40).map(move |j| Anchor::corner(tip(i).lerp(tip(i + 1), j as f64 / 40.0)))).collect();
SubPath::new(anchors, true)
}
/// A document with path `sub` filled with `rule`, stroked `stroke` points wide when that is more
/// than 0, and its id.
fn long_path(sub: SubPath, rule: FillRule, stroke: f64) -> (Document, NodeId) {
let mut d = Document::new(110.0, 80.0);
let l = d.layers[0].id;
let id = d.alloc_id();
let line = if stroke > 0.0 { Paint::solid(Color::BLACK) } else { Paint::None };
let mut n = Node::path(id, PathData::single(sub), Appearance::basic(Paint::solid(Color::rgb(0.1, 0.5, 0.8)), line, stroke));
if let NodeKind::Path { rule: r, .. } = &mut n.kind {
*r = rule;
}
let id = d.insert(Some(l), 0, n).unwrap();
(d, id)
}
/// `d` with anchor `i` of the first subpath of path `id` and its handles moved by `by`.
fn move_anchor(d: &Document, id: NodeId, i: usize, by: Vec2) -> Document {
let mut d = d.clone();
if let Some(NodeKind::Path { path, .. }) = d.node_mut(id).map(|n| &mut n.kind) {
let a = &mut path.subpaths[0].anchors[i];
(a.p, a.h_in, a.h_out) = (a.p + by, a.h_in + by, a.h_out + by);
}
d
}
/// Moving one anchor of a long filled path changes the fill only round the segments at that
/// anchor, with either fill rule, a smooth or a corner anchor, and a closing segment.
#[test]
fn moving_an_anchor_of_a_long_path_changes_only_round_its_segments() {
for rule in [FillRule::NonZero, FillRule::EvenOdd] {
let (old, id) = long_path(wavy(2000, 45.0, 32.0), rule, 0.0);
for i in [0, 700, 1001] {
let a = area(redraw(&old, &move_anchor(&old, id, i, Vec2::new(4.0, -3.0))));
assert!(a.width() < 8.0 && a.height() < 8.0, "{rule:?}, anchor {i}: {a:?}");
}
}
}
/// The fill of an open path closes it with a line from its last anchor to its first: moving an
/// end changes where that line was and is too.
#[test]
fn moving_an_end_of_an_open_filled_path_changes_the_line_that_closes_its_fill() {
let mut half = wavy(3000, 45.0, 32.0);
half.anchors.truncate(1500);
half.closed = false;
let (old, id) = long_path(half, FillRule::NonZero, 0.0);
for i in [0, 1499] {
redraw(&old, &move_anchor(&old, id, i, Vec2::new(0.0, 12.0)));
}
}
/// Where a path covers its middle twice, the two fill rules draw it differently: an anchor moved
/// across that part changes only round its segments.
#[test]
fn moving_an_anchor_where_a_path_crosses_itself_changes_only_round_its_segments() {
for rule in [FillRule::NonZero, FillRule::EvenOdd] {
let (old, id) = long_path(star(), rule, 0.0);
let a = area(redraw(&old, &move_anchor(&old, id, 20, Vec2::new(-6.0, 5.0))));
assert!(a.width() < 12.0 && a.height() < 12.0, "{rule:?}: {a:?}");
}
}
/// A stroke with miter joints changes round the moved anchor's segments and as far as its spikes
/// reach from them, and the open end of a stroke with square caps as far as its cap's corners.
#[test]
fn moving_an_anchor_of_a_stroked_path_changes_as_far_as_its_joints_reach() {
let (old, id) = long_path(star(), FillRule::NonZero, 1.5);
let a = area(redraw(&old, &move_anchor(&old, id, 60, Vec2::new(3.0, 4.0))));
assert!(a.width() < 30.0, "{a:?}");
let mut open = star();
open.closed = false;
let (old, id) = long_path(open, FillRule::NonZero, 3.0);
let mut sq = old.clone();
if let Some(AppearanceItem::Stroke(s)) = sq.node_mut(id).unwrap().appearance.items.get_mut(1) {
s.cap = vectorcraft_doc::LineCap::Square;
}
let a = area(redraw(&sq, &move_anchor(&sq, id, 279, Vec2::new(5.0, 2.0))));
assert!(a.width() < 50.0, "{a:?}");
}
/// A compound path with a hole changes only round the moved anchor of the member it moved in.
#[test]
fn moving_an_anchor_of_a_compound_path_changes_only_round_its_segments() {
for rule in [FillRule::NonZero, FillRule::EvenOdd] {
let mut old = Document::new(110.0, 80.0);
let l = old.layers[0].id;
let (outer, inner) = (old.alloc_id(), old.alloc_id());
let mut hole = wavy(600, 25.0, 15.0);
if rule == FillRule::NonZero {
// Wound the other way, so it is a hole by either rule.
hole.anchors.reverse();
for a in &mut hole.anchors {
std::mem::swap(&mut a.h_in, &mut a.h_out);
}
}
let members = vec![
Arc::new(Node::path(outer, PathData::single(wavy(1500, 45.0, 32.0)), Appearance::default())),
Arc::new(Node::path(inner, PathData::single(hole), Appearance::default())),
];
let mut compound = Node::new(old.alloc_id(), NodeKind::Compound { children: members, rule });
compound.appearance = Appearance::basic(Paint::solid(Color::rgb(0.8, 0.3, 0.1)), Paint::None, 0.0).into();
old.insert(Some(l), 0, compound).unwrap();
let new = move_anchor(&old, inner, 150, Vec2::new(3.0, 3.0));
let a = area(redraw(&old, &new));
assert!(a.width() < 8.0 && a.height() < 8.0, "{rule:?}: {a:?}");
}
}
/// A gradient fill and a dashed stroke are laid out by the whole path: moving one anchor changes
/// all of it, as does adding an anchor.
#[test]
fn a_path_painted_by_its_whole_shape_changes_whole_when_an_anchor_moves() {
let (plain, id) = long_path(wavy(400, 45.0, 32.0), FillRule::NonZero, 1.0);
let mut graded = plain.clone();
let stops = vec![vectorcraft_color::GradientStop::new(0.0, Color::BLACK), vectorcraft_color::GradientStop::new(1.0, Color::WHITE)];
graded.node_mut(id).unwrap().appearance.fill_mut().unwrap().paint = Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(
vectorcraft_color::Gradient::new(vectorcraft_color::GradientKind::Linear, stops),
)));
let mut dashed = plain.clone();
if let Some(AppearanceItem::Stroke(s)) = dashed.node_mut(id).unwrap().appearance.items.get_mut(1) {
s.dash = Some(vectorcraft_doc::Dash { pattern: vec![3.0, 2.0], ..Default::default() });
}
for old in [graded, dashed] {
let a = area(redraw(&old, &move_anchor(&old, id, 100, Vec2::new(2.0, 2.0))));
assert!(a.width() > 80.0 && a.height() > 60.0, "{a:?}");
}
let mut added = plain.clone();
if let Some(NodeKind::Path { path, .. }) = added.node_mut(id).map(|n| &mut n.kind) {
path.subpaths[0].anchors.insert(10, Anchor::corner(Point::new(50.0, 40.0)));
}
let a = area(redraw(&plain, &added));
assert!(a.width() > 80.0 && a.height() > 60.0, "{a:?}");
}
/// Changing a 3D effect's parameters on `make`'s object, from `before` to `after`.
fn three_d_change(make: impl Fn(&mut Document) -> Node, id: &str, before: serde_json::Value, after: serde_json::Value) -> Changed {
let effect = |params: serde_json::Value| vectorcraft_doc::Effect { id: id.into(), params, visible: true };
let mut old = Document::new(110.0, 80.0);
let l = old.layers[0].id;
let mut n = make(&mut old);
n.appearance.effects.push(effect(before));
let n = old.insert(Some(l), 0, n).unwrap();
let mut new = old.clone();
new.node_mut(n).unwrap().appearance.effects[0] = effect(after);
redraw(&old, &new)
}
/// Type and a group draw a 3D effect as solids that reach past their letters and members: a
/// shallower or turned solid changes where the deeper one drew too.
#[test]
fn a_3d_effect_changed_on_type_or_a_group_changes_where_its_solid_was() {
use vectorcraft_doc::{CharStyle, TextObject};
let blue = Color::rgb(0.1, 0.2, 0.6);
let type_k = move |d: &mut Document| {
let style = CharStyle { size: 30.0, fill: Paint::solid(blue), ..Default::default() };
Node::new(d.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(40.0, 50.0), "K", style))))
};
let group = move |d: &mut Document| {
let (a, b) = (rect(d, Rect::new(40.0, 30.0, 50.0, 50.0), blue), rect(d, Rect::new(52.0, 30.0, 60.0, 50.0), blue));
Node::group(d.alloc_id(), vec![Arc::new(a), Arc::new(b)])
};
let at = |depth: f64| serde_json::json!({"depth": depth, "position": "isometricTop"});
for make in [&type_k as &dyn Fn(&mut Document) -> Node, &group] {
for (id, before, after) in [
("threeD.extrude", at(60.0), at(5.0)),
("threeD.inflate", at(40.0), at(2.0)),
("threeD.rotate", serde_json::json!({"rotationX": 0.0}), serde_json::json!({"rotationX": 80.0})),
] {
// `redraw` holds the pixels drawn again only where it changed to drawing it all, and
// only an area of the document is drawn again.
area(three_d_change(make, id, before, after));
}
}
// Type on a path, a group with a hidden member, and a group in a group.
let on_path = move |d: &mut Document| {
let style = CharStyle { size: 14.0, fill: Paint::solid(blue), ..Default::default() };
let mut t = TextObject::point(Point::ZERO, "Along", style);
let line = kurbo::Line::new((30.0, 55.0), (80.0, 35.0)).to_path(0.1);
t.kind = vectorcraft_doc::TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&line), start: 0.0, end: None };
t.xf = Affine::IDENTITY;
t.cached_bounds = Some(vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t).bounds);
Node::new(d.alloc_id(), NodeKind::Text(Box::new(t)))
};
let hiding = move |d: &mut Document| {
let mut hidden = rect(d, Rect::new(10.0, 10.0, 20.0, 20.0), blue);
hidden.visible = false;
let shown = rect(d, Rect::new(40.0, 30.0, 60.0, 50.0), blue);
Node::group(d.alloc_id(), vec![Arc::new(hidden), Arc::new(shown)])
};
let nested = move |d: &mut Document| {
let inner = group(d);
Node::group(d.alloc_id(), vec![Arc::new(inner)])
};
for make in [&on_path as &dyn Fn(&mut Document) -> Node, &hiding, &nested] {
area(three_d_change(make, "threeD.extrude", at(60.0), at(5.0)));
}
// A revolved path, and revolved type, which Revolve leaves as it is.
let path = move |d: &mut Document| rect(d, Rect::new(40.0, 30.0, 60.0, 50.0), blue);
for make in [&path as &dyn Fn(&mut Document) -> Node, &type_k] {
area(three_d_change(make, "threeD.revolve", serde_json::json!({"offset": 30.0}), serde_json::json!({"offset": 0.0})));
}
}
/// A renderer that drew a document measures what an edit changed through what it keeps
/// ([`Renderer::changed`]): the same area as [`changed`], and the 3D art it made to measure the
/// edit it draws the edit with, making none again. [`changed`] makes its own, and the renderer
/// makes the art again to draw it.
#[test]
fn a_renderer_measures_an_edit_with_the_3d_art_it_draws() {
use vectorcraft_doc::{CharStyle, TextObject};
let mut old = Document::new(110.0, 80.0);
let style = CharStyle { size: 30.0, fill: Paint::solid(Color::rgb(0.1, 0.2, 0.6)), ..Default::default() };
let mut n = Node::new(old.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(40.0, 50.0), "K", style))));
let extrude = |depth: f64| vectorcraft_doc::Effect {
id: "threeD.extrude".into(),
params: serde_json::json!({"depth": depth, "position": "isometricTop"}),
visible: true,
};
n.appearance.effects.push(extrude(60.0));
let l = old.layers[0].id;
let id = old.insert(Some(l), 0, n).unwrap();
let mut new = old.clone();
new.node_mut(id).unwrap().appearance.effects[0] = extrude(5.0);
let opts = RenderOptions::default();
let _fonts = crate::tests_fontchange::fonts_steady();
let (measured, built, apart) = crate::tests_fontchange::with_fonts_unchanged(|| {
let mut r = Renderer::new();
r.render(&old, W, H, view(), &opts);
let measured = area(r.changed(&old, &new, &opts));
r.render(&new, W, H, view(), &opts);
let mut fresh = Renderer::new();
fresh.render(&old, W, H, view(), &opts);
let _ = changed(&old, &new);
fresh.render(&new, W, H, view(), &opts);
(measured, r.stats.three_d_built, fresh.stats.three_d_built)
});
assert_eq!(measured, area(changed(&old, &new)), "as changed measures it");
assert_eq!(built, 0, "drawn with the art made to measure it");
assert_eq!(apart, 1, "changed keeps nothing for the renderer");
}
/// An Image Trace object shown with its source image (`view`): its hidden source, a red image at
/// the left, and two traced shapes, at the right; the object's id, and the ids of the source and
/// of the second shape.
fn traced(view: &str) -> (Document, NodeId, NodeId, NodeId) {
let mut d = Document::new(W as f64, H as f64);
let mut png = vec![];
let red = image::RgbaImage::from_pixel(1, 1, image::Rgba([255, 0, 0, 255]));
{
let __dyn: image::DynamicImage = red.into();
let (__w, __h) = (__dyn.width(), __dyn.height());
let (__layout, __sample, __raw) = match __dyn {
image::DynamicImage::ImageLuma8(b) => (craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageLumaA8(b) => (craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageRgb8(b) => (craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageRgba8(b) => (craft_image_codecs::ChannelLayout::Rgba, craft_image_codecs::SampleType::U8, b.into_raw()),
image::DynamicImage::ImageLuma16(b) => (
craft_image_codecs::ChannelLayout::Gray,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
image::DynamicImage::ImageLumaA16(b) => (
craft_image_codecs::ChannelLayout::GrayA,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
image::DynamicImage::ImageRgb16(b) => (
craft_image_codecs::ChannelLayout::Rgb,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
image::DynamicImage::ImageRgba16(b) => (
craft_image_codecs::ChannelLayout::Rgba,
craft_image_codecs::SampleType::U16,
b.into_raw().into_iter().flat_map(|s| s.to_ne_bytes()).collect(),
),
other => (craft_image_codecs::ChannelLayout::Rgba, craft_image_codecs::SampleType::U8, other.into_rgba8().into_raw()),
};
let __cimg = craft_image_codecs::Image::from_raw(__w, __h, __layout, __sample, __raw).unwrap();
craft_image_codecs::encode(&__cimg, craft_image_codecs::Format::Png, &craft_image_codecs::EncodeOptions::default())
.map(|__b| png.extend_from_slice(&__b))
}
.unwrap();
d.images.insert("red".into(), vectorcraft_doc::ImageBlob::new("image/png", png));
let source = red_image(&mut d, 10.0);
let a = rect(&mut d, Rect::new(60.0, 10.0, 70.0, 20.0), Color::rgb(0.0, 0.5, 0.0));
let b = rect(&mut d, Rect::new(80.0, 10.0, 90.0, 20.0), Color::rgb(1.0, 0.5, 0.0));
let ids = (source.id, b.id);
let mut g = Node::group(d.alloc_id(), vec![Arc::new(source), Arc::new(a), Arc::new(b)]);
g.extras_mut().trace = Some(Box::new(serde_json::json!({ "view": view })));
let l = d.layers[0].id;
let g = d.insert(Some(l), 0, g).unwrap();
(d, g, ids.0, ids.1)
}
/// A hidden 30 pt square of the red image at (`x`, 10), as an Image Trace object's source.
fn red_image(d: &mut Document, x: f64) -> Node {
let xf = Affine::translate((x, 10.0)) * Affine::scale(30.0);
let im = vectorcraft_doc::ImageObject { key: "red".into(), width: 1, height: 1, xf, link: None, placement: Default::default(), pixels: None };
let mut source = Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)));
source.visible = false;
source
}
/// Draws `new` again only where the renderer that drew `old` on screen, its Image Trace objects in
/// their views, measures that it changed, and checks that this is `new` drawn whole.
fn redraw_traced(old: &Document, new: &Document) -> Changed {
let opts = RenderOptions { trace_views: true, ..Default::default() };
let after = Renderer::new().render(new, W, H, view(), &opts);
let mut r = Renderer::new();
let before = r.render(old, W, H, view(), &opts);
let red = |r: &Rendered| r.pixels.chunks(4).any(|p| p[0] > 200 && p[1] < 60);
assert!(red(&before) || red(&after), "a source shows");
let measured = r.changed(old, new, &opts);
patched(&mut r, &before, new, measured, &after, &opts);
measured
}
#[test]
fn moving_a_trace_objects_source_changes_where_it_shows() {
for view in ["sourceImage", "outlinesWithSourceImage"] {
let (old, _, source, _) = traced(view);
let mut new = old.clone();
new.node_mut(source).unwrap().transform(Affine::translate((5.0, 30.0)), false);
let a = area(redraw_traced(&old, &new));
assert!(a.contains(Point::new(12.0, 12.0)) && a.contains(Point::new(44.0, 69.0)), "{view}: before and after: {a:?}");
}
}
/// A trace object's source that is first again after an edit (undoing Send to Back on a traced
/// shape), or a new source in its place, draws where it shows.
#[test]
fn a_trace_objects_new_first_member_is_its_source() {
let (back, g, source, shape) = traced("sourceImage");
// The shape sent to the back, before the source.
let mut sent = back.clone();
let children = sent.node_mut(g).unwrap().children_mut().unwrap();
let at = children.iter().position(|c| c.id == shape).unwrap();
let moved = children.remove(at);
children.insert(0, moved);
redraw_traced(&sent, &back);
// A new source image, with an id of its own.
let mut replaced = back.clone();
let new_source = red_image(&mut replaced, 55.0);
let children = replaced.node_mut(g).unwrap().children_mut().unwrap();
assert_eq!(children[0].id, source);
children[0] = Arc::new(new_source);
redraw_traced(&back, &replaced);
}
/// Recoloring a traced shape changes only the shape, as the free measure and the renderer that drew
/// the trace object in its view measure it. Through the renderer the area is bounded, not drawn
/// again and compared: in this view (outlines with the source image) a partial render of the
/// outlines differs from the whole by one in alpha on a few dozen hairline pixels, either way,
/// which is older than this test and has nothing to do with what changed (the recolor changes no
/// pixel in this view).
#[test]
fn recolouring_a_traced_shape_changes_only_the_shape() {
let (old, _, _, shape) = traced("outlinesWithSourceImage");
let mut new = old.clone();
new.node_mut(shape).unwrap().appearance.fill_mut().unwrap().paint = Paint::solid(Color::rgb(0.0, 0.0, 1.0));
// The shape, half its 2 pt stroke and a pixel's anti-aliasing, at most: measured by the
// renderer that drew the trace object in its view, and by the free measure.
let opts = RenderOptions { trace_views: true, ..Default::default() };
let mut r = Renderer::new();
r.render(&old, W, H, view(), &opts);
let measured = area(r.changed(&old, &new, &opts));
let shape = Rect::new(80.0, 10.0, 90.0, 20.0).inflate(2.0, 2.0);
for (what, a) in [("measured", measured), ("free", area(redraw(&old, &new)))] {
assert!(a.union(shape) == shape, "{what}: only the shape: {a:?}");
}
}
/// Templates and guides that the view hides draw nothing: an edit to them changes nothing.
#[test]
fn an_edit_to_what_the_view_hides_changes_nothing() {
let mut old = Document::new(W as f64, H as f64);
let template = Node::layer(old.alloc_id(), "Template", vectorcraft_doc::LayerColor::Preset(1));
let template = old.insert(None, usize::MAX, template).unwrap();
if let Some(NodeKind::Layer { template: t, .. }) = old.node_mut(template).map(|n| &mut n.kind) {
*t = true;
}
let traced = rect(&mut old, Rect::new(10.0, 10.0, 40.0, 40.0), Color::rgb(0.5, 0.5, 0.5));
let traced = old.insert(Some(template), 0, traced).unwrap();
let mut guide = rect(&mut old, Rect::new(60.0, 10.0, 90.0, 40.0), Color::BLACK);
if let NodeKind::Path { guide: g, .. } = &mut guide.kind {
*g = true;
}
let l = old.layers[0].id;
let guide = old.insert(Some(l), 0, guide).unwrap();
let mut new = old.clone();
for id in [traced, guide] {
new.node_mut(id).unwrap().transform(Affine::translate((5.0, 5.0)), false);
}
let opts = RenderOptions { hide_templates: true, hide_guides: true, ..Default::default() };
let mut r = Renderer::new();
r.render(&old, W, H, view(), &opts);
assert_eq!(r.changed(&old, &new, &opts), Changed::Nothing);
assert!(matches!(changed(&old, &new), Changed::Area(_)), "shown, they change");
}
/// Overprint Preview and separations draw objects through the inks they print, not through the
/// art a renderer keeps for them: a renderer measures an edit there holding none of the 3D art it
/// made to measure it, and as [`changed`] does.
#[test]
fn an_edit_measured_under_overprint_holds_no_art() {
use vectorcraft_doc::{CharStyle, TextObject};
let mut old = Document::new(110.0, 80.0);
let style = CharStyle { size: 30.0, fill: Paint::solid(Color::rgb(0.1, 0.2, 0.6)), ..Default::default() };
let mut n = Node::new(old.alloc_id(), NodeKind::Text(Box::new(TextObject::point(Point::new(40.0, 50.0), "K", style))));
let extrude = |depth: f64| vectorcraft_doc::Effect {
id: "threeD.extrude".into(),
params: serde_json::json!({"depth": depth, "position": "isometricTop"}),
visible: true,
};
n.appearance.effects.push(extrude(60.0));
let l = old.layers[0].id;
let id = old.insert(Some(l), 0, n).unwrap();
let mut new = old.clone();
new.node_mut(id).unwrap().appearance.effects[0] = extrude(5.0);
let _fonts = crate::tests_fontchange::fonts_steady();
let held = |opts: &RenderOptions| {
crate::tests_fontchange::with_fonts_unchanged(|| {
let mut r = Renderer::new();
r.render(&old, W, H, view(), opts);
(area(r.changed(&old, &new, opts)), r.measured_bytes())
})
};
let (_, on_screen) = held(&RenderOptions::default());
assert!(on_screen > 0, "the screen view holds the art it measured with");
let (measured, overprinted) = held(&RenderOptions { overprint_preview: true, ..Default::default() });
assert_eq!(overprinted, 0);
// A consistency check: the area itself doesn't tell the branch taken.
assert_eq!(measured, area(changed(&old, &new)), "as changed measures it");
}
/// Symbol editing mode on screen doesn't draw the instance it was entered from: an edit to that
/// instance changes nothing there, and changes where it draws in an export.
#[test]
fn an_edit_to_the_instance_symbol_editing_came_from_changes_nothing_on_screen() {
use vectorcraft_doc::{Symbol, SymbolEdit};
let mut old = Document::new(W as f64, H as f64);
let art = rect(&mut old, Rect::new(20.0, 20.0, 50.0, 50.0), Color::rgb(0.0, 0.5, 0.0));
old.symbols.push(Symbol { dynamic: false, name: "Square".into(), art: Arc::new(art.clone()) });
let inst = Node::new(old.alloc_id(), NodeKind::SymbolInstance { symbol: "Square".into(), xf: Affine::IDENTITY });
let l = old.layers[0].id;
let inst = old.insert(Some(l), 0, inst).unwrap();
let layer = old.add_layer(Some("Square"));
let copy = old.reid(&art);
old.insert(Some(layer), usize::MAX, copy).unwrap();
old.symbol_edit = Some(SymbolEdit {
symbol: "Square".into(),
layer,
instance: Some(inst),
xf: Affine::IDENTITY,
group: false,
changed: false,
back_isolation: None,
back_layer: None,
});
let mut new = old.clone();
new.node_mut(inst).unwrap().transform(Affine::translate((30.0, 30.0)), false);
let screen = RenderOptions { isolated: Some(layer), ..Default::default() };
let mut r = Renderer::new();
r.render(&old, W, H, view(), &screen);
assert_eq!(r.changed(&old, &new, &screen), Changed::Nothing);
let export = RenderOptions::default();
let mut r = Renderer::new();
r.render(&old, W, H, view(), &export);
assert!(matches!(r.changed(&old, &new, &export), Changed::Area(_)), "an export draws it");
}