mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-18 13:33:51 +00:00
Expand kept a face only when its topmost fill had paint, and an edge only when its topmost stroke had paint and a weight. A face or edge drawn by a lower row under an unpainted top row was removed, and one whose only painted row was hidden was kept as a visible path. Expand now keeps a face or edge when it is shown, its opacity is above 0, and any fill or stroke row is shown, has paint and an opacity above 0 (a stroke also a weight above 0), with all of its rows. The rows are checked with the new Appearance::has_drawn_fill and has_drawn_stroke. Merge carried a face's topmost fill paint by the same topmost-row test. It now carries every row of each face that draws by this rule, and of each edge, pins their unplaced gradients to the old outline as repaint_from does, and leaves the strokes' pen pressure, tilt, bearing and rotation behind, since the rebuilt parts are other paths. Docs: livePaint.expand params text, docs/mcp.md, and a line in docs/target-app-parity.md, which also drops a repeated Live Paint Selection marquee line.
559 lines
27 KiB
Rust
559 lines
27 KiB
Rust
use super::*;
|
||
|
||
#[test]
|
||
fn hidden_attributes_show_again() {
|
||
let mut a = Appearance::default_art();
|
||
assert!(!a.has_hidden() && !a.show_all());
|
||
a.stroke_mut().unwrap().visible = false;
|
||
a.items[0].effects_mut().push(Effect { id: "distort.roughen".into(), params: serde_json::Value::Null, visible: false });
|
||
assert!(a.has_hidden());
|
||
assert!(a.show_all());
|
||
assert!(!a.has_hidden() && a.items.iter().all(AppearanceItem::visible) && a.items[0].effects()[0].visible);
|
||
}
|
||
|
||
#[test]
|
||
fn basic_appearance() {
|
||
let a = Appearance::default_art();
|
||
assert!(a.is_basic());
|
||
assert_eq!(a.fill_paint(), Paint::solid(Color::WHITE));
|
||
assert_eq!(a.stroke_width(), 1.0);
|
||
}
|
||
|
||
#[test]
|
||
fn rebase_moves_fills_by_the_box_and_strokes_by_their_inflated_box() {
|
||
use vectorcraft_color::{Gradient, GradientGeom, GradientPaint};
|
||
use vectorcraft_geom::{Point, Rect};
|
||
let placed = |x: f64| {
|
||
let mut g = GradientPaint::new(Gradient::default());
|
||
g.geom = Some(GradientGeom { start: Point::new(x, 0.0), end: Point::new(x + 10.0, 0.0), aspect: 1.0, focal: None });
|
||
Paint::Gradient(Box::new(g))
|
||
};
|
||
let mut a = Appearance::basic(placed(0.0), placed(-5.0), 10.0);
|
||
a.rebase_gradients(Rect::new(0.0, 0.0, 100.0, 100.0), Rect::new(100.0, 0.0, 300.0, 100.0));
|
||
let start = |p: Paint| match p {
|
||
Paint::Gradient(g) => g.geom.unwrap().start,
|
||
_ => panic!("a gradient"),
|
||
};
|
||
// The fill's start stays on the left edge; the stroke's on its inflated box's (−5 → 95).
|
||
assert_eq!((start(a.fill_paint()), start(a.stroke_paint())), (Point::new(100.0, 0.0), Point::new(95.0, 0.0)));
|
||
}
|
||
|
||
#[test]
|
||
fn items_by_index() {
|
||
let mut a = Appearance::default_art();
|
||
a.items.push(AppearanceItem::Fill(FillLayer::new(Paint::None)));
|
||
// [Fill white, Stroke black, Fill none]
|
||
assert_eq!(a.fill_at(None).unwrap().paint, Paint::None);
|
||
assert_eq!(a.fill_at(Some(0)).unwrap().paint, Paint::solid(Color::WHITE));
|
||
assert!(a.fill_at(Some(1)).is_none() && a.stroke_at(Some(0)).is_none() && a.fill_at(Some(9)).is_none());
|
||
assert_eq!(a.item_of_kind(Some(1), false), Some(1));
|
||
assert_eq!(a.item_of_kind(Some(1), true), None);
|
||
assert_eq!(a.fill_for(Some(1)).unwrap().paint, Paint::None);
|
||
assert!(a.set_fill_at(Some(0), Paint::solid(Color::BLACK)));
|
||
assert!(!a.set_stroke_at(Some(0), Paint::None));
|
||
assert_eq!(a.fill_at(Some(0)).unwrap().paint, Paint::solid(Color::BLACK));
|
||
a.effects_mut(Some(1)).unwrap().push(Effect { id: "distort.roughen".into(), params: serde_json::Value::Null, visible: true });
|
||
assert_eq!(a.effects_at(Some(1)).unwrap().len(), 1);
|
||
assert!(a.effects_at(None).unwrap().is_empty() && a.effects_mut(Some(3)).is_none());
|
||
assert_eq!((a.items[1].kind_name(), a.items[2].kind_name()), ("stroke", "fill"));
|
||
}
|
||
|
||
#[test]
|
||
fn basic_means_one_plain_fill_and_stroke() {
|
||
let stroke = || AppearanceItem::Stroke(StrokeLayer::new(Paint::solid(Color::BLACK), 1.0));
|
||
let mut a = Appearance { items: vec![stroke(), stroke()], ..Appearance::default() };
|
||
assert!(!a.is_basic(), "two strokes");
|
||
a.items.pop();
|
||
assert!(a.is_basic() && Appearance::default().is_basic());
|
||
let mut b = Appearance::default_art();
|
||
b.stroke_mut().unwrap().visible = false;
|
||
assert!(!b.is_basic(), "a hidden stroke");
|
||
let mut c = Appearance::default_art();
|
||
c.fill_mut().unwrap().opacity = 0.5;
|
||
assert!(!c.is_basic(), "fill opacity");
|
||
let mut d = Appearance::default_art();
|
||
d.items.push(AppearanceItem::Fill(FillLayer::new(Paint::None)));
|
||
assert!(!d.is_basic(), "two fills");
|
||
let mut e = Appearance::default_art();
|
||
e.effects.push(Effect { id: "distort.roughen".into(), params: serde_json::Value::Null, visible: true });
|
||
assert!(!e.is_basic(), "an effect");
|
||
}
|
||
|
||
#[test]
|
||
fn drawn_fills_and_strokes_count_every_row() {
|
||
let fill = |p: Paint| AppearanceItem::Fill(FillLayer::new(p));
|
||
let stroke = |p: Paint, w: f64| AppearanceItem::Stroke(StrokeLayer::new(p, w));
|
||
let black = || Paint::solid(Color::BLACK);
|
||
assert!(!Appearance::default().has_drawn_fill() && !Appearance::default().has_drawn_stroke());
|
||
// A painted lower row draws under an unpainted top row.
|
||
let a = Appearance { items: vec![fill(black()), stroke(black(), 2.0), fill(Paint::None), stroke(Paint::None, 1.0)], ..Appearance::default() };
|
||
assert!(a.has_drawn_fill() && a.has_drawn_stroke());
|
||
// A hidden painted row, a zero opacity or a zero weight draws nothing.
|
||
let mut b = Appearance { items: vec![fill(black()), stroke(black(), 2.0)], ..Appearance::default() };
|
||
b.fill_mut().unwrap().visible = false;
|
||
b.stroke_mut().unwrap().visible = false;
|
||
assert!(!b.has_drawn_fill() && !b.has_drawn_stroke());
|
||
let mut c = Appearance::default_art();
|
||
c.fill_mut().unwrap().opacity = 0.0;
|
||
c.stroke_mut().unwrap().opacity = 0.0;
|
||
assert!(!c.has_drawn_fill() && !c.has_drawn_stroke());
|
||
let d = Appearance::basic(Paint::None, black(), 0.0);
|
||
assert!(!d.has_drawn_fill() && !d.has_drawn_stroke());
|
||
}
|
||
|
||
#[test]
|
||
fn set_creates_missing() {
|
||
let mut a = Appearance::default();
|
||
a.set_fill(Paint::solid(Color::BLACK));
|
||
a.set_stroke(Paint::solid(Color::WHITE));
|
||
assert_eq!(a.items.len(), 2);
|
||
assert!(matches!(a.items[0], AppearanceItem::Fill(_)));
|
||
}
|
||
|
||
/// #852: pen pressure is kept simplified along the stroke and read back by position.
|
||
#[test]
|
||
fn pressure_profile_samples_simplify_and_interpolate() {
|
||
// A steady ramp keeps only its ends; a bump keeps its peak.
|
||
let ramp = PressureProfile::from_samples((0..=100).map(|i| (i as f64 / 100.0, i as f64 / 100.0))).unwrap();
|
||
assert_eq!(ramp.points, vec![(0.0, 0.0), (1.0, 1.0)]);
|
||
assert!((ramp.at(0.25) - 0.25).abs() < 1e-9);
|
||
let bump = PressureProfile::from_samples([(0.0, 0.2), (0.3, 0.2), (0.5, 0.9), (0.7, 0.2), (1.0, 0.2)]).unwrap();
|
||
assert!(bump.points.contains(&(0.5, 0.9)) && (bump.at(0.4) - 0.55).abs() < 1e-9, "{bump:?}");
|
||
// Junk is clamped or dropped; positions never go back; nothing at all is no profile.
|
||
let junk = PressureProfile::from_samples([(f64::NAN, 0.5), (0.5, 7.0), (0.2, -1.0), (2.0, f64::INFINITY)]).unwrap();
|
||
assert_eq!(junk.points, vec![(0.5, 1.0), (0.5, 0.0)]);
|
||
assert!(PressureProfile::from_samples([(f64::NAN, 0.5)]).is_none());
|
||
assert_eq!(PressureProfile::default().at(0.3), PressureProfile::MID);
|
||
// A long noisy stroke stays bounded.
|
||
let noisy = PressureProfile::from_samples((0..1_000_000).map(|i| (i as f64 / 1e6, (i % 2) as f64))).unwrap();
|
||
assert!(noisy.points.len() <= PressureProfile::MAX_POINTS);
|
||
// Out-of-order points (a hand-edited file) still read within 0..1.
|
||
let odd = PressureProfile { points: vec![(1.0, 5.0), (0.0, -3.0)] };
|
||
assert!((0.0..=1.0).contains(&odd.at(0.5)));
|
||
}
|
||
|
||
#[test]
|
||
fn pressure_profile_extends_and_reverses() {
|
||
let old = PressureProfile { points: vec![(0.0, 0.0), (1.0, 1.0)] };
|
||
let added = PressureProfile { points: vec![(0.0, 1.0), (1.0, 0.0)] };
|
||
// A 30 pt path continued by 10 pt: its ramp fills the first three quarters.
|
||
let joined = PressureProfile::extended(Some(&old), 30.0, Some(&added), 10.0).unwrap();
|
||
assert!((joined.at(0.75) - 1.0).abs() < 1e-9 && (joined.at(0.375) - 0.5).abs() < 1e-9 && joined.at(1.0) == 0.0, "{joined:?}");
|
||
// A side without pressure is half way.
|
||
let half = PressureProfile::extended(None, 10.0, Some(&added), 10.0).unwrap();
|
||
assert_eq!(half.at(0.25), PressureProfile::MID);
|
||
assert!(PressureProfile::extended(None, 10.0, None, 10.0).is_none());
|
||
assert_eq!(PressureProfile::extended(Some(&old), 0.0, None, f64::NAN), Some(old.clone()));
|
||
assert_eq!(old.reversed().points, vec![(0.0, 1.0), (1.0, 0.0)]);
|
||
}
|
||
|
||
/// #764: a pen's bearing or barrel rotation is kept the shorter way round between samples, so
|
||
/// 170° then −170° turns through 180°, not through 0°.
|
||
#[test]
|
||
fn angle_profiles_join_samples_the_shorter_way_round() {
|
||
let across = AngleProfile::from_samples([(0.0, 170.0), (1.0, -170.0)]).unwrap();
|
||
assert_eq!(across.points, vec![(0.0, 170.0), (1.0, 190.0)]);
|
||
assert_eq!(across.at(0.5), 180.0);
|
||
assert!((across.at(0.75) + 175.0).abs() < 1e-9, "{}", across.at(0.75));
|
||
// Turns past a whole turn keep counting, and read back within −180..180°.
|
||
let spin = AngleProfile::from_samples((0..=40).map(|i| (f64::from(i) / 40.0, f64::from(i * 30) - 180.0))).unwrap();
|
||
assert!((spin.points.last().unwrap().1 - 1380.0).abs() < 1e-9, "{spin:?}");
|
||
assert!((spin.at(1.0) + 60.0).abs() < 1e-9 && spin.points.len() == 2, "{spin:?}");
|
||
// Junk is dropped; nothing at all is no profile, and no profile reads 0°.
|
||
let junk = AngleProfile::from_samples([(f64::NAN, 5.0), (0.5, f64::INFINITY), (0.2, 400.0)]).unwrap();
|
||
assert_eq!(junk.points, vec![(0.2, 40.0)]);
|
||
assert!(AngleProfile::from_samples([(0.5, f64::NAN)]).is_none());
|
||
assert_eq!(AngleProfile::default().at(0.3), 0.0);
|
||
let noisy = AngleProfile::from_samples((0..1_000_000).map(|i| (f64::from(i) / 1e6, f64::from(i % 2) * 90.0))).unwrap();
|
||
assert!(noisy.points.len() <= PressureProfile::MAX_POINTS);
|
||
// Continued: the old part, then the new one; a side without an angle is 0°. Reversed, the
|
||
// angles stay what they were.
|
||
let old = AngleProfile { points: vec![(0.0, 90.0), (1.0, 90.0)] };
|
||
let joined = AngleProfile::extended(Some(&old), 30.0, None, 10.0).unwrap();
|
||
assert!((joined.at(0.5) - 90.0).abs() < 1e-9 && joined.at(1.0) == 0.0, "{joined:?}");
|
||
assert!(AngleProfile::extended(None, 10.0, None, 10.0).is_none());
|
||
assert_eq!(AngleProfile::extended(Some(&old), 0.0, None, 0.0), Some(old.clone()));
|
||
assert_eq!(across.reversed().points, vec![(0.0, 190.0), (1.0, 170.0)]);
|
||
// A part that turned more than half a turn between two of its samples keeps that turn when
|
||
// the path is continued, and so does the new part.
|
||
let quarter_turns = AngleProfile::from_samples([(0.0, 0.0), (1.0 / 3.0, 90.0), (2.0 / 3.0, 180.0), (1.0, 270.0)]).unwrap();
|
||
assert_eq!(quarter_turns.points, vec![(0.0, 0.0), (1.0, 270.0)]);
|
||
let added = AngleProfile { points: vec![(0.0, -80.0), (1.0, 280.0)] };
|
||
let joined = AngleProfile::extended(Some(&quarter_turns), 10.0, Some(&added), 10.0).unwrap();
|
||
assert!((joined.at(0.25) - 135.0).abs() < 1e-9, "{joined:?}");
|
||
assert!((joined.at(0.75) - 100.0).abs() < 1e-9, "{joined:?}");
|
||
}
|
||
|
||
/// Strokes saved before pen pressure load as they were, and are written without it.
|
||
#[test]
|
||
fn strokes_without_pressure_round_trip_unchanged() {
|
||
let json = serde_json::to_value(StrokeLayer::new(Paint::None, 2.0)).unwrap();
|
||
for key in ["pressure", "tilt", "bearing", "rotation"] {
|
||
assert!(json.get(key).is_none(), "{key}");
|
||
}
|
||
let st: StrokeLayer = serde_json::from_value(json).unwrap();
|
||
assert_eq!(st.pressure, None);
|
||
let pressed = StrokeLayer { pressure: Some(PressureProfile::sample()), ..st };
|
||
let back: StrokeLayer = serde_json::from_value(serde_json::to_value(&pressed).unwrap()).unwrap();
|
||
assert_eq!(back, pressed);
|
||
let mut ap = Appearance::basic(Paint::None, Paint::None, 1.0);
|
||
ap.stroke_mut().unwrap().pressure = Some(PressureProfile::sample());
|
||
assert_eq!(ap.without_pressure().stroke().unwrap().pressure, None);
|
||
// The pen's tilt, bearing and rotation load, save and stay behind the same way.
|
||
let posed = StrokeLayer {
|
||
tilt: Some(PressureProfile::sample()),
|
||
bearing: Some(AngleProfile::sample()),
|
||
rotation: Some(AngleProfile { points: vec![(0.0, -45.0)] }),
|
||
..back
|
||
};
|
||
let again: StrokeLayer = serde_json::from_value(serde_json::to_value(&posed).unwrap()).unwrap();
|
||
assert_eq!(again, posed);
|
||
let mut ap = Appearance::basic(Paint::None, Paint::None, 1.0);
|
||
*ap.stroke_mut().unwrap() = posed;
|
||
let st = ap.without_pressure().stroke().cloned().unwrap();
|
||
assert_eq!((st.pressure, st.tilt, st.bearing, st.rotation), (None, None, None, None));
|
||
}
|
||
|
||
/// The Lens profile's widths at its middle, a quarter of the way along and past its end.
|
||
#[test]
|
||
fn profile_interp() {
|
||
let p = WidthProfile::lens();
|
||
assert_eq!(p.at(0.5), (1.0, 1.0));
|
||
// The lens is a parabola between its ends, so a quarter of the way along is 0.75: above the
|
||
// 0.5 a straight taper would give.
|
||
assert_eq!(p.at(0.25), (0.75, 0.75));
|
||
assert_eq!(p.at(2.0), (0.0, 0.0));
|
||
}
|
||
|
||
/// The width runs smoothly between points: it passes through them, has one slope either side
|
||
/// of one, and never overshoots the widths its points set.
|
||
#[test]
|
||
fn profile_is_smooth_between_points() {
|
||
let p = [(0.0, 1.0, 2.0), (0.5, 0.2, 2.0), (1.0, 1.0, 2.0)];
|
||
assert!((WidthProfile::at_points(&p, 0.5).0 - 0.2).abs() < 1e-12);
|
||
let slope = |t: f64| (WidthProfile::at_points(&p, t + 1e-6).0 - WidthProfile::at_points(&p, t - 1e-6).0) / 2e-6;
|
||
// A local minimum at the middle point is flat there, so the two sides agree.
|
||
assert!(slope(0.5).abs() < 1e-3, "{}", slope(0.5));
|
||
for k in 0..=100 {
|
||
let w = WidthProfile::at_points(&p, k as f64 / 100.0).0;
|
||
assert!((0.2..=1.0).contains(&w), "{w} at {k}");
|
||
}
|
||
// The side with no points of its own stays flat.
|
||
for k in 0..=100 {
|
||
assert!((WidthProfile::at_points(&p, k as f64 / 100.0).1 - 2.0).abs() < 1e-12);
|
||
}
|
||
}
|
||
|
||
/// A run with only two points takes its secant as both end slopes, so it stays a straight
|
||
/// taper on each side instead of becoming a smoothstep.
|
||
#[test]
|
||
fn profile_two_point_runs_are_linear() {
|
||
let p = [(0.0, 0.0, 1.0), (1.0, 1.0, 0.0)];
|
||
for k in 0..=100 {
|
||
let t = k as f64 / 100.0;
|
||
let (l, r) = WidthProfile::at_points(&p, t);
|
||
assert!((l - t).abs() < 1e-12, "left {l} at {t}");
|
||
assert!((r - (1.0 - t)).abs() < 1e-12, "right {r} at {t}");
|
||
}
|
||
}
|
||
|
||
/// The lens's one-sided end slopes make it a parabola: at a quarter of the way it is 0.75,
|
||
/// above the 0.5 a straight line between its points would give.
|
||
#[test]
|
||
fn profile_lens_is_convex() {
|
||
let p = WidthProfile::lens();
|
||
assert!((p.at(0.25).0 - 0.75).abs() < 1e-12);
|
||
assert!((p.at(0.75).0 - 0.75).abs() < 1e-12);
|
||
for k in 1..25 {
|
||
let t = k as f64 / 100.0;
|
||
assert!(p.at(t).0 > 2.0 * t, "{} at {t}", p.at(t).0);
|
||
assert!(p.at(1.0 - t).0 > 2.0 * t, "{} at {}", p.at(1.0 - t).0, 1.0 - t);
|
||
}
|
||
}
|
||
|
||
/// A step still steps, and the smooth runs either side meet it flat.
|
||
#[test]
|
||
fn profile_steps_stay_steps() {
|
||
let p = [(0.0, 1.0, 1.0), (0.5, 1.0, 1.0), (0.5, 2.0, 2.0), (1.0, 2.0, 2.0)];
|
||
assert_eq!(WidthProfile::at_points(&p, 0.5), (1.0, 1.0));
|
||
assert_eq!(WidthProfile::at_points(&p, 0.5 + 1e-6), (2.0, 2.0));
|
||
assert_eq!(WidthProfile::at_points(&p, 0.5 - 1e-6), (1.0, 1.0));
|
||
assert_eq!(WidthProfile::at_points(&p, 0.25), (1.0, 1.0));
|
||
assert_eq!(WidthProfile::at_points(&p, 0.75), (2.0, 2.0));
|
||
}
|
||
|
||
/// Moving a point only reshapes the segments beside it (local influence), not the whole path.
|
||
#[test]
|
||
fn profile_points_only_affect_the_curve_around_them() {
|
||
// A monotone run, so no neighbouring slope is held flat by a local extremum.
|
||
let a = [(0.0, 0.0, 0.0), (0.25, 0.3, 0.3), (0.5, 0.5, 0.5), (0.75, 0.7, 0.7), (1.0, 1.0, 1.0)];
|
||
let mut b = a;
|
||
b[3] = (0.75, 0.9, 0.9);
|
||
// Moving p[3] changes the slopes at p[2] and p[3], so p[1] and p[4] also shape the
|
||
// curve: nothing before p[1] may move.
|
||
for k in 0..=24 {
|
||
let t = k as f64 / 100.0;
|
||
assert_eq!(WidthProfile::at_points(&a, t), WidthProfile::at_points(&b, t), "at {t}");
|
||
}
|
||
assert_ne!(WidthProfile::at_points(&a, 0.3), WidthProfile::at_points(&b, 0.3));
|
||
}
|
||
|
||
#[test]
|
||
fn profile_presets_round_trip_their_ids() {
|
||
for p in WidthProfile::PRESETS {
|
||
let prof = WidthProfile::preset(p.id).unwrap();
|
||
assert_eq!(prof.preset_id(), Some(p.id));
|
||
assert_eq!(WidthProfile::id_of(Some(&prof)), p.id);
|
||
}
|
||
assert_eq!(WidthProfile::id_of(None), "uniform");
|
||
assert_eq!(WidthProfile::id_of(Some(&WidthProfile { points: vec![(0.0, 0.3, 0.3)] })), "custom");
|
||
assert!(WidthProfile::preset("nope").is_none());
|
||
assert_eq!(WidthProfile::lens().points, vec![(0.0, 0.0, 0.0), (0.5, 1.0, 1.0), (1.0, 0.0, 0.0)]);
|
||
}
|
||
|
||
#[test]
|
||
fn arrowhead_names_are_stable_and_every_one_is_listed_once() {
|
||
// Saved files store these names: they may only ever be appended to.
|
||
const SAVED: [&str; 41] = [
|
||
"Triangle",
|
||
"TriangleOpen",
|
||
"Circle",
|
||
"CircleOpen",
|
||
"Square",
|
||
"SquareOpen",
|
||
"Bar",
|
||
"Diamond",
|
||
"Arrow",
|
||
"ArrowOpen",
|
||
"Barbed",
|
||
"HalfArrowLeft",
|
||
"HalfArrowRight",
|
||
"Concave",
|
||
"DoubleBar",
|
||
"Feather",
|
||
"DotOnBar",
|
||
"Chevron",
|
||
"DoubleArrow",
|
||
"Target",
|
||
"Star",
|
||
"Cross",
|
||
"Plus",
|
||
"Hexagon",
|
||
"HexagonOpen",
|
||
"Tag",
|
||
"TagOpen",
|
||
"HalfCircle",
|
||
"Drop",
|
||
"Slash",
|
||
"DoubleSlash",
|
||
"DiamondOpen",
|
||
"TriangleReverse",
|
||
"Swallowtail",
|
||
"Bracket",
|
||
"Fork",
|
||
"Leaf",
|
||
"Kite",
|
||
"TriangleBar",
|
||
"Oval",
|
||
"LineArrow",
|
||
];
|
||
for name in SAVED {
|
||
let a: Arrowhead = serde_json::from_value(serde_json::json!(name)).unwrap();
|
||
assert_eq!(serde_json::to_value(&a).unwrap(), name);
|
||
assert_eq!(Arrowhead::ALL.iter().filter(|x| **x == a).count(), 1, "{name} in the menu once");
|
||
}
|
||
let labels: std::collections::HashSet<&str> = Arrowhead::ALL.iter().map(|a| a.label()).collect();
|
||
assert_eq!(labels.len(), Arrowhead::ALL.len(), "labels are distinct");
|
||
}
|
||
|
||
/// A custom head: a triangle from its tip back 3 units, 2 units right and 1 left of its line.
|
||
fn custom_head() -> Arrowhead {
|
||
use vectorcraft_geom::{PathData, Point, SubPath};
|
||
let path = PathData::single(SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(3.0, 2.0), Point::new(3.0, -1.0)], true));
|
||
Arrowhead::Custom(std::sync::Arc::new(CustomArrowhead::new("Wedge".into(), path)))
|
||
}
|
||
|
||
#[test]
|
||
fn custom_arrowheads_carry_their_art_and_measure_it() {
|
||
let head = custom_head();
|
||
assert_eq!((head.name(), head.label()), ("Wedge", "Custom"));
|
||
assert_eq!(head.reach(), 3.0f64.hypot(2.0));
|
||
assert_eq!(head.half_width(), 2.0);
|
||
let Arrowhead::Custom(c) = &head else { panic!("custom") };
|
||
assert_eq!(c.stop(), 1.5, "the line stops halfway along the head");
|
||
// Saved with the stroke, art and all, beside the built-in heads' names.
|
||
let mut st = StrokeLayer::new(Paint::solid(Color::BLACK), 2.0);
|
||
(st.start_arrow, st.end_arrow) = (Some(Arrowhead::Triangle), Some(head.clone()));
|
||
let json = serde_json::to_value(&st).unwrap();
|
||
assert_eq!(json["start_arrow"], "Triangle");
|
||
assert_eq!(json["end_arrow"]["Custom"]["name"], "Wedge");
|
||
let back: StrokeLayer = serde_json::from_value(json).unwrap();
|
||
assert_eq!(back, st);
|
||
// Extended, the tip sits the stop past the end point; on it, only the reach counts.
|
||
assert_eq!(head.length(), 1.5 + head.reach());
|
||
assert_eq!(st.head_reach(true), head.length() * 2.0 + 1.0);
|
||
st.arrow_align = ArrowAlign::Tip;
|
||
assert_eq!(st.head_reach(true), head.reach() * 2.0 + 1.0);
|
||
}
|
||
|
||
#[test]
|
||
fn custom_arrowheads_out_of_bounds_draw_nothing() {
|
||
let Arrowhead::Custom(c) = custom_head() else { panic!("custom") };
|
||
let mut path = c.path.clone();
|
||
path.subpaths[0].anchors[1] = vectorcraft_geom::Anchor::corner(vectorcraft_geom::Point::new(1e9, 0.0));
|
||
// A file can hold what `new` drops: reading it drops it too.
|
||
let json = serde_json::to_value(CustomArrowhead { name: "Wedge".into(), path }).unwrap();
|
||
let far: CustomArrowhead = serde_json::from_value(json).unwrap();
|
||
assert_eq!((far.name.as_str(), far.path.subpaths.len()), ("Wedge", 0));
|
||
assert_eq!((far.reach(), far.half_width(), far.stop()), (0.0, 0.0, 0.0));
|
||
let anchors = vec![vectorcraft_geom::Anchor::corner(vectorcraft_geom::Point::new(1.0, 0.0)); CustomArrowhead::MAX_ANCHORS + 1];
|
||
let many = CustomArrowhead::new("Many".into(), vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::new(anchors, true)));
|
||
assert!(many.path.subpaths.is_empty(), "too many anchors");
|
||
// Empty subpaths add no anchors, and still count.
|
||
let mut hollow = c.path.clone();
|
||
hollow.subpaths.extend(std::iter::repeat_n(vectorcraft_geom::SubPath::new(vec![], false), CustomArrowhead::MAX_ANCHORS));
|
||
assert!(!CustomArrowhead::fits(&hollow), "too many subpaths");
|
||
let json = serde_json::to_value(CustomArrowhead { name: "Hollow".into(), path: hollow }).unwrap();
|
||
let hollow: CustomArrowhead = serde_json::from_value(json).unwrap();
|
||
assert!(hollow.path.subpaths.is_empty(), "too many subpaths, read back");
|
||
}
|
||
|
||
#[test]
|
||
fn arrow_align_defaults_to_extend_and_round_trips() {
|
||
let mut st = StrokeLayer::new(Paint::solid(Color::BLACK), 2.0);
|
||
assert_eq!(st.arrow_align, ArrowAlign::Extend);
|
||
// The default is not written, so older readers see the same JSON as before.
|
||
assert!(!serde_json::to_string(&st).unwrap().contains("arrow_align"));
|
||
let old: StrokeLayer = serde_json::from_str(r#"{"paint":{"type":"none"},"width":2.0}"#).unwrap();
|
||
assert_eq!(old.arrow_align, ArrowAlign::Extend);
|
||
st.arrow_align = ArrowAlign::Tip;
|
||
let back: StrokeLayer = serde_json::from_str(&serde_json::to_string(&st).unwrap()).unwrap();
|
||
assert_eq!(back, st);
|
||
}
|
||
|
||
#[test]
|
||
fn outset_covers_arrowheads() {
|
||
let mut a = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 4.0);
|
||
a.stroke_mut().unwrap().join = LineJoin::Round;
|
||
assert_eq!(a.outset(), 2.0);
|
||
let st = a.stroke_mut().unwrap();
|
||
st.end_arrow = Some(Arrowhead::Triangle);
|
||
st.arrow_scale = (100.0, 200.0);
|
||
assert_eq!(st.arrow_weight(false), 4.0);
|
||
assert_eq!(st.arrow_weight(true), 8.0);
|
||
let reach = Arrowhead::Triangle.reach();
|
||
assert_eq!((st.head_reach(false), st.head_reach(true)), (0.0, reach * 8.0 + 2.0));
|
||
// A 32 pt head whose tip sits up to its length (plus the cap) past the end point.
|
||
assert_eq!(a.outset(), reach * 8.0 + 2.0);
|
||
// The line arrow's arms spread twice as wide, so it reaches further from its tip.
|
||
a.stroke_mut().unwrap().end_arrow = Some(Arrowhead::LineArrow);
|
||
assert!(Arrowhead::LineArrow.reach() > reach);
|
||
assert_eq!(a.outset(), Arrowhead::LineArrow.reach() * 8.0 + 2.0);
|
||
a.stroke_mut().unwrap().end_arrow = Some(Arrowhead::Triangle);
|
||
a.stroke_mut().unwrap().width = 0.01;
|
||
assert_eq!(a.stroke().unwrap().arrow_weight(true), 0.25, "heads keep a minimum size");
|
||
}
|
||
|
||
#[test]
|
||
fn outset_depends_on_align() {
|
||
let mut a = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 10.0);
|
||
a.stroke_mut().unwrap().join = LineJoin::Round;
|
||
assert_eq!(a.outset(), 5.0);
|
||
a.stroke_mut().unwrap().align = StrokeAlign::Outside;
|
||
assert_eq!(a.outset(), 10.0);
|
||
// Open paths stroke inside-aligned strokes centred.
|
||
a.stroke_mut().unwrap().align = StrokeAlign::Inside;
|
||
assert_eq!(a.outset(), 5.0);
|
||
assert_eq!((a.stroke().unwrap().side_reach(true), a.stroke().unwrap().body(true)), (0.0, (10.0, Some(true))));
|
||
}
|
||
|
||
#[test]
|
||
fn outset_covers_miter_spikes_projecting_caps_and_profile_maxima() {
|
||
let mut a = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 2.0);
|
||
// Miter joins can spike out to the limit × half the weight.
|
||
assert_eq!(a.outset(), 10.0);
|
||
let st = a.stroke_mut().unwrap();
|
||
st.join = LineJoin::Bevel;
|
||
st.cap = LineCap::Square;
|
||
assert!((a.outset() - std::f64::consts::SQRT_2).abs() < 1e-12, "a projecting cap's corner");
|
||
let st = a.stroke_mut().unwrap();
|
||
st.cap = LineCap::Round;
|
||
st.profile = Some(WidthProfile { points: vec![(0.0, 0.5, 2.5), (1.0, 1.0, 1.0)] });
|
||
assert_eq!(st.profile_max(), 2.5);
|
||
assert_eq!(a.outset(), 2.5);
|
||
a.stroke_mut().unwrap().paint = Paint::None;
|
||
assert_eq!(a.outset(), 0.0, "an unpainted stroke");
|
||
}
|
||
|
||
#[test]
|
||
fn contents_slot_follows_item_edits_and_round_trips() {
|
||
let fill = || AppearanceItem::Fill(FillLayer::new(Paint::None));
|
||
let mut a = Appearance { items: vec![fill(), fill(), fill()], ..Appearance::default() };
|
||
assert_eq!((a.contents_at(), a.split_contents().1.len()), (0, 3), "all items above by default");
|
||
a.set_contents_at(1);
|
||
assert!(!a.is_basic());
|
||
// [0 | 1 2]: removing below shifts the slot, removing above doesn't.
|
||
a.remove_item(2);
|
||
assert_eq!(a.contents_at(), 1);
|
||
a.remove_item(0);
|
||
assert_eq!((a.contents_at(), a.contents_index), (0, None));
|
||
// Inserting next to the slot joins the item below it.
|
||
a.items.push(fill());
|
||
a.set_contents_at(1); // [0 | 1]
|
||
a.insert_item(1, fill());
|
||
assert_eq!(a.contents_at(), 2);
|
||
a.insert_item(3, fill()); // [0 1 | 2 3]
|
||
assert_eq!(a.contents_at(), 2);
|
||
// Moves keep their side when landing next to the slot, cross it otherwise.
|
||
assert_eq!(a.move_item(3, 2), Some(2));
|
||
assert_eq!(a.contents_at(), 2, "stays above");
|
||
a.move_item(3, 0);
|
||
assert_eq!(a.contents_at(), 3, "crossed below");
|
||
a.move_item(0, 3);
|
||
assert_eq!(a.contents_at(), 2, "crossed above");
|
||
assert_eq!(a.move_item(9, 0), None);
|
||
// Saved only when set; older files load with every item above.
|
||
let json = serde_json::to_string(&a).unwrap();
|
||
assert!(json.contains("\"contents_index\":2"));
|
||
assert_eq!(serde_json::from_str::<Appearance>(&json).unwrap(), a);
|
||
let old: Appearance = serde_json::from_str(r#"{"items":[]}"#).unwrap();
|
||
assert_eq!(old.contents_index, None);
|
||
assert!(!serde_json::to_string(&Appearance::default_art()).unwrap().contains("contents_index"));
|
||
}
|
||
|
||
/// The issue's case (#4174): two circles with different fills, the same stroke and the same
|
||
/// effect share the stroke and the effect, not the fills; a shared stroke at another place in one
|
||
/// stack maps to its own index there; nothing shared shares nothing; equal stacks share all.
|
||
#[test]
|
||
fn mixed_appearances_share_their_equal_rows() {
|
||
let stroke = AppearanceItem::Stroke(StrokeLayer::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), 11.0));
|
||
let fill = |c: Color| AppearanceItem::Fill(FillLayer::new(Paint::solid(c)));
|
||
let feather = Effect { id: "stylize.feather".into(), params: serde_json::json!({"radius": 5}), visible: true };
|
||
let a = Appearance { items: vec![fill(Color::rgb(1.0, 1.0, 0.0)), stroke.clone()], effects: vec![feather.clone()], ..Appearance::default() };
|
||
let b = Appearance { items: vec![fill(Color::rgb(1.0, 0.0, 0.0)), stroke.clone()], effects: vec![feather.clone()], ..Appearance::default() };
|
||
let shared = SharedStack::of(&[&a, &b]);
|
||
assert_eq!(shared.items, vec![vec![1, 1]], "the stroke, not the fills");
|
||
assert_eq!(shared.effects, vec![vec![0, 0]]);
|
||
// The stroke under an extra fill in the second object.
|
||
let c =
|
||
Appearance { items: vec![fill(Color::BLACK), fill(Color::WHITE), stroke.clone()], effects: vec![feather.clone()], ..Appearance::default() };
|
||
let shared = SharedStack::of(&[&a, &c]);
|
||
assert_eq!(shared.items, vec![vec![1, 2]]);
|
||
assert_eq!(shared.item_in(1, 1), Some(2));
|
||
assert_eq!(shared.item_in(0, 1), None);
|
||
// Nothing alike.
|
||
let d = Appearance { items: vec![fill(Color::WHITE)], ..Appearance::default() };
|
||
let none = SharedStack::of(&[&a, &d]);
|
||
assert!(none.items.is_empty() && none.effects.is_empty());
|
||
// Equal stacks share everything, each row where it is.
|
||
assert_eq!(SharedStack::of(&[&a, &a.clone(), &a.clone()]).items, vec![vec![0, 0, 0], vec![1, 1, 1]]);
|
||
}
|
||
|
||
/// Matches keep their stacking order: two equal rows in the opposite order match once.
|
||
#[test]
|
||
fn aligned_rows_never_cross() {
|
||
assert_eq!(align(&[1, 2], &[2, 1], |a, b| a == b).iter().filter(|m| m.is_some()).count(), 1);
|
||
assert_eq!(align(&[1, 2, 3], &[9, 1, 3], |a, b| a == b), vec![Some(1), None, Some(2)]);
|
||
assert_eq!(align::<i32>(&[], &[1], |a, b| a == b), Vec::<Option<usize>>::new());
|
||
}
|