Merge main into #8458

# Conflicts:
#	crates/engine/src/cmd/brushlib.rs
#	crates/engine/src/tests/brushlib.rs
#	crates/ui-egui/src/i18n/bg.tsv
#	crates/ui-egui/src/i18n/bs.tsv
#	crates/ui-egui/src/i18n/ca.tsv
#	crates/ui-egui/src/i18n/cs.tsv
#	crates/ui-egui/src/i18n/da.tsv
#	crates/ui-egui/src/i18n/de.tsv
#	crates/ui-egui/src/i18n/el.tsv
#	crates/ui-egui/src/i18n/es.tsv
#	crates/ui-egui/src/i18n/fi.tsv
#	crates/ui-egui/src/i18n/fr.tsv
#	crates/ui-egui/src/i18n/gu.tsv
#	crates/ui-egui/src/i18n/hi.tsv
#	crates/ui-egui/src/i18n/hu.tsv
#	crates/ui-egui/src/i18n/id.tsv
#	crates/ui-egui/src/i18n/it.tsv
#	crates/ui-egui/src/i18n/ja.tsv
#	crates/ui-egui/src/i18n/ka.tsv
#	crates/ui-egui/src/i18n/ko.tsv
#	crates/ui-egui/src/i18n/nl.tsv
#	crates/ui-egui/src/i18n/pl.tsv
#	crates/ui-egui/src/i18n/pt-br.tsv
#	crates/ui-egui/src/i18n/ru.tsv
#	crates/ui-egui/src/i18n/sv.tsv
#	crates/ui-egui/src/i18n/tr.tsv
#	crates/ui-egui/src/i18n/uk.tsv
#	crates/ui-egui/src/i18n/vi.tsv
#	crates/ui-egui/src/i18n/zh-hans.tsv
#	crates/ui-egui/src/i18n/zh-hant.tsv
#	crates/ui-egui/src/panels/tests_brush_libraries.rs
This commit is contained in:
bflatastic committed 2026-11-20 02:07:18 +07:00
commit ff417eba17
175 files changed
+9494 -444

No files matched your search

+22 -8
View File
@@ -34,6 +34,7 @@ const WIDE_LINES: &str =
"lines wider than 2.11 mm (the widest lineweight) are written at 2.11 mm: Alter Paths for Appearance writes their true width";
const STROKE_EXTRAS: &str = "stroke alignment, width profiles, arrowheads and brushes are left out (Maximize Editability writes strokes as lines)";
const CLIPPING: &str = "clipping masks are not applied: the art they clip is written whole";
const DISTORTED_IMAGES: &str = "images changed by Perspective Distort or Free Distort are written as the nearest parallelogram";
const TYPE_ITEMS: &str = "fills and strokes added to whole type objects are left out of text entities (outline the text to keep them)";
/// The warning for an image left out because it can't be decoded: the note raster exports give
/// (`vectorcraft-engine`'s `rasterfx::undecoded_warning`).
@@ -671,7 +672,18 @@ impl<'a> Scene<'a> {
self.shape(n, &bp, *rule);
}
NodeKind::Text(t) => self.text(n, t),
NodeKind::Image(im) => self.image(&self.doc.shown_image(n, im)),
NodeKind::Image(im) => match vectorcraft_doc::image_quad::nearest_affine(n) {
// DXF clips nothing, so a distorted image is written at the affine placement nearest
// its corners, with the warning once it is written.
Some(xf) => {
if self.image(&ImageObject { xf, ..self.doc.shown_image(n, im).into_owned() }) {
self.warn(DISTORTED_IMAGES);
}
}
None => {
self.image(&self.doc.shown_image(n, im));
}
},
NodeKind::SymbolInstance { symbol, xf } => {
let doc = self.doc;
if self.symbol_nodes >= vectorcraft_doc::MAX_SYMBOL_NODES {
@@ -1325,18 +1337,19 @@ impl<'a> Scene<'a> {
name
}
/// A placed image, linked to its file (written once per image).
fn image(&mut self, im: &ImageObject) {
/// A placed image, linked to its file (written once per image). False when no `IMAGE` entity is
/// written.
fn image(&mut self, im: &ImageObject) -> bool {
if !self.o.version.handles() {
self.warn(NO_IMAGES);
return;
return false;
}
if !self.o.include_images {
self.note_setting(IMAGES_OFF);
return;
return false;
}
let Some(i) = self.image_def(im) else { return };
let Some((dw, dh)) = self.images.get(i).map(|d| (f64::from(d.size.0), f64::from(d.size.1))) else { return };
let Some(i) = self.image_def(im) else { return false };
let Some((dw, dh)) = self.images.get(i).map(|d| (f64::from(d.size.0), f64::from(d.size.1))) else { return false };
let (w, h) = (f64::from(im.width.max(1)), f64::from(im.height.max(1)));
let map = self.to_dxf * im.xf;
let lin = |v: kurbo::Vec2| (map * v.to_point()) - (map * Point::ZERO);
@@ -1349,7 +1362,7 @@ impl<'a> Scene<'a> {
let at = map * Point::new(0.0, h);
let handle = self.handle();
let reactor = self.handle();
let Some(def) = self.images.get_mut(i) else { return };
let Some(def) = self.images.get_mut(i) else { return false };
def.reactors.push((reactor, handle));
let def = def.handle;
let layer = self.layer.clone();
@@ -1375,6 +1388,7 @@ impl<'a> Scene<'a> {
if self.o.version >= crate::DxfVersion::R2010 {
self.e.int(290, 0);
}
true
}
/// The image file for image `im`, encoded once in the chosen format (`None`: left out).
+31
View File
@@ -984,6 +984,37 @@ fn images_can_be_left_out_with_their_files() {
assert!(r12.warnings.iter().any(|w| w.contains("no images")) && r12.setting_notes.is_empty());
}
/// DXF does not clip, so an image changed by Perspective Distort is written as one image at the
/// placement nearest its corners, with a warning; an undistorted image gets no warning.
#[test]
fn a_distorted_image_is_written_as_its_nearest_parallelogram_with_a_warning() {
let mut d = image_and_fill_doc(Paint::None);
let warned = |o: &DxfOutput| o.warnings.iter().any(|w| w.contains("Perspective Distort or Free Distort"));
assert!(!warned(&export(&d, &opts(&d)).unwrap()));
let id = d.layers[0].children().unwrap()[1].id;
let q = [(12.0, 20.0), (28.0, 20.0), (30.0, 30.0), (10.0, 30.0)].map(|(x, y)| Point::new(x, y));
d.node_mut(id).unwrap().set_image_corners(q).unwrap();
let out = export(&d, &opts(&d)).unwrap();
assert!(warned(&out), "{:?}", out.warnings);
assert_eq!(kinds(&out).iter().filter(|k| *k == "IMAGE").count(), 1, "{:?}", kinds(&out));
// Placed as an undistorted image with the nearest affine placement as its transform would be.
let near = vectorcraft_doc::image_quad::nearest_affine(d.node(id).unwrap()).unwrap();
let mut plain = d.clone();
let n = plain.node_mut(id).unwrap();
n.extras_mut().image_quad = None;
if let NodeKind::Image(im) = &mut n.kind {
im.xf = near;
}
let placement = |o: &DxfOutput| {
let e = entities(o).into_iter().find(|e| kind(e) == "IMAGE").expect("an IMAGE");
[10, 20, 11, 21, 12, 22].map(|c| all(&e, c))
};
assert_eq!(placement(&out), placement(&export(&plain, &opts(&plain)).unwrap()));
// With images left out, no IMAGE is written and the distortion warning does not appear.
let left_out = export(&d, &DxfOptions { include_images: false, ..opts(&d) }).unwrap();
assert!(!warned(&left_out), "{:?}", left_out.warnings);
}
#[test]
fn images_and_hatches_are_left_out_independently_and_the_cnc_preset_leaves_out_both() {
let d = image_and_fill_doc(Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
+97
View File
@@ -10,6 +10,7 @@ pub mod freeform;
pub mod gradient;
pub mod harmony;
pub mod libraries;
pub mod oklab;
pub mod palette_io;
pub mod recolor;
pub mod swatch;
@@ -340,6 +341,49 @@ pub fn hsb_to_rgb([h, s, v]: [f32; 3]) -> [f32; 3] {
[r + m, g + m, b + m]
}
/// HSL (hue in degrees 0..360, saturation and lightness 0..1) of RGB numbers 0..1, with no color
/// conversion, as CSS Color 4 converts sRGB to HSL
/// (<https://www.w3.org/TR/css-color-4/#rgb-to-hsl>). The hue is 0 while the saturation is
/// powerless, and a color outside 0..1 that gives a negative saturation turns its hue by 180°. As in
/// the specification's conversion, a lightness of 0.00001 or less, a lightness less than 0.00001
/// below 1, or a saturation of 0.00001 or less reads as a gray.
pub fn rgb_to_hsl([r, g, b]: [f32; 3]) -> [f32; 3] {
const EPSILON: f32 = 1e-5;
let max = r.max(g).max(b);
let min = r.min(g).min(b);
let d = max - min;
let l = (max + min) / 2.0;
if d <= 0.0 {
return [0.0, 0.0, l];
}
let mut s = if l.abs() <= EPSILON || (1.0 - l).abs() < EPSILON { 0.0 } else { (max - l) / l.min(1.0 - l) };
let mut h = rgb_to_hsb([r, g, b])[0];
if s < 0.0 {
h += 180.0;
s = -s;
}
if s <= EPSILON {
return [0.0, 0.0, l];
}
let h = h.rem_euclid(360.0);
[if h >= 360.0 { 0.0 } else { h }, s, l]
}
/// RGB numbers 0..1 of HSL `[h, s, l]` (hue in degrees, saturation and lightness 0..1), as CSS
/// Color 4 converts HSL to sRGB (<https://www.w3.org/TR/css-color-4/#hsl-to-rgb>): the inverse of
/// [`rgb_to_hsl`]. A hue outside 0..360 wraps into that range before the conversion, so -120°
/// gives the color of 240° and a hue of 10,000,000,000° the color of 280°. The specification's
/// sample code uses JavaScript's remainder operator and gives a different color for a negative hue.
pub fn hsl_to_rgb([h, s, l]: [f32; 3]) -> [f32; 3] {
let h = h.rem_euclid(360.0);
let a = s * l.min(1.0 - l);
let f = |n: f32| {
let k = (n + h / 30.0).rem_euclid(12.0);
l - a * (k - 3.0).min(9.0 - k).clamp(-1.0, 1.0)
};
[f(0.0), f(8.0), f(4.0)]
}
/// `new` expressed in the colour model of `orig` ([`Color::in_model`]): results of colour operations
/// (harmonies, blends, inversions, recolouring) keep the model of the colour they came from.
pub fn keep_model(orig: Color, new: Color) -> Color {
@@ -499,6 +543,59 @@ mod tests {
}
}
/// The HSL examples of CSS Color 4, section 7 (<https://www.w3.org/TR/css-color-4/#the-hsl-notation>),
/// the first six rows, and two hues outside 0..360 that wrap into that range.
#[test]
fn hsl_follows_css_color_4() {
for (hsl, hex) in [
([0.0, 1.0, 0.5], "#ff0000"),
([120.0, 1.0, 0.5], "#00ff00"),
([120.0, 1.0, 0.25], "#008000"),
([120.0, 1.0, 0.75], "#80ff80"),
([240.0, 1.0, 0.5], "#0000ff"),
([60.0, 1.0, 0.5], "#ffff00"),
([360.0, 1.0, 0.5], "#ff0000"),
([-120.0, 1.0, 0.5], "#0000ff"),
] {
let [r, g, b] = hsl_to_rgb(hsl);
assert_eq!(Color::rgb(r, g, b).to_hex(), hex, "{hsl:?}");
}
let [h, s, l] = rgb_to_hsl([1.0, 0.5, 0.0]);
assert!((h - 30.0).abs() < 1e-4 && (s - 1.0).abs() < 1e-6 && (l - 0.5).abs() < 1e-6, "{h} {s} {l}");
let [h, s, l] = rgb_to_hsl(Color::rgb8(255, 128, 0).to_rgb_uncalibrated());
assert!((h - 30.0).abs() < 0.2 && (s - 1.0).abs() < 1e-6 && (l - 0.5).abs() < 1e-3, "{h} {s} {l}");
// A gray has no hue: the hue is 0 and the saturation 0, at any lightness.
for v in [0.0, 0.25, 0.5, 1.0] {
assert_eq!(rgb_to_hsl([v, v, v]), [0.0, 0.0, v]);
}
// Black and white keep any hue and saturation they are given.
assert_eq!(hsl_to_rgb([200.0, 0.7, 0.0]), [0.0, 0.0, 0.0]);
assert_eq!(hsl_to_rgb([200.0, 0.7, 1.0]), [1.0, 1.0, 1.0]);
// A color past the gamut that gives a negative saturation turns its hue by 180°.
let [h, s, _] = rgb_to_hsl([1.2, 1.5, 1.4]);
assert!(s > 0.0 && (h - (160.0 + 180.0)).abs() < 1e-3, "{h} {s}");
// A huge hue wraps before the channels are worked out: 10,000,000,000° is 280°.
let (huge, wrapped) = (hsl_to_rgb([10_000_000_000.0, 1.0, 0.5]), hsl_to_rgb([280.0, 1.0, 0.5]));
assert!((0..3).all(|i| (huge[i] - wrapped[i]).abs() < 1e-6), "{huge:?} {wrapped:?}");
}
/// The 216 web colors go to HSL and back to the same 8-bit color.
#[test]
fn hsl_roundtrip() {
let steps = [0x00, 0x33, 0x66, 0x99, 0xcc, 0xff];
for r in steps {
for g in steps {
for b in steps {
let c = Color::rgb8(r, g, b);
let [h, s, l] = rgb_to_hsl(c.to_rgb_uncalibrated());
assert!((0.0..360.0).contains(&h) && (0.0..=1.0).contains(&s) && (0.0..=1.0).contains(&l), "{}", c.to_hex());
let back = hsl_to_rgb([h, s, l]).map(|v| (v * 255.0).round() as u8);
assert_eq!(back, [r, g, b], "{}", c.to_hex());
}
}
}
}
#[test]
fn cmyk_conversions() {
assert_eq!(Color::cmyk(0.0, 0.0, 0.0, 1.0).to_rgb_uncalibrated(), [0.0, 0.0, 0.0]);
+14 -6
View File
@@ -99,18 +99,24 @@ pub fn builtin_library(id: &str) -> Option<Arc<SwatchLibrary>> {
// ---------- colour construction ----------
/// sRGB (0..=1, gamma encoded) of OKLab `(l, a, b)`, unclamped.
/// sRGB (0..=1, gamma encoded) of OKLab `(l, a, b)`, unclamped. A linear channel below
/// −0.0031308 is encoded with the curve's sign turned, as CSS Color 4's extended sRGB does
/// (<https://www.w3.org/TR/css-color-4/#color-conversion-code>).
pub(crate) fn oklab_to_srgb(l: f64, a: f64, b: f64) -> [f64; 3] {
oklab_to_linear_srgb(l, a, b).map(|v| if v.abs() <= 0.003_130_8 { 12.92 * v } else { v.signum() * (1.055 * v.abs().powf(1.0 / 2.4) - 0.055) })
}
/// Linear sRGB of OKLab `(l, a, b)`, unclamped.
pub(crate) fn oklab_to_linear_srgb(l: f64, a: f64, b: f64) -> [f64; 3] {
let l_ = l + 0.396_337_777_4 * a + 0.215_803_757_3 * b;
let m_ = l - 0.105_561_345_8 * a - 0.063_854_172_8 * b;
let s_ = l - 0.089_484_177_5 * a - 1.291_485_548_0 * b;
let (l3, m3, s3) = (l_ * l_ * l_, m_ * m_ * m_, s_ * s_ * s_);
let lin = [
[
4.076_741_662_1 * l3 - 3.307_711_591_3 * m3 + 0.230_969_929_2 * s3,
-1.268_438_004_6 * l3 + 2.609_757_401_1 * m3 - 0.341_319_396_5 * s3,
-0.004_196_086_3 * l3 - 0.703_418_614_7 * m3 + 1.707_614_701_0 * s3,
];
lin.map(|v| if v <= 0.003_130_8 { 12.92 * v } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 })
]
}
/// OKLab `[l, a, b]` of a colour's display RGB.
@@ -118,11 +124,13 @@ pub fn to_oklab(c: &Color) -> [f64; 3] {
srgb_to_oklab(c.to_rgb_uncalibrated())
}
/// OKLab `[l, a, b]` of sRGB `rgb` (0..=1, gamma encoded).
/// OKLab `[l, a, b]` of sRGB `rgb` (0..=1, gamma encoded). A channel below −0.04045 is decoded
/// with the curve's sign turned, as CSS Color 4's extended sRGB does
/// (<https://www.w3.org/TR/css-color-4/#color-conversion-code>).
pub(crate) fn srgb_to_oklab(rgb: [f32; 3]) -> [f64; 3] {
let [r, g, b] = rgb.map(|v| {
let v = f64::from(v);
if v <= 0.040_45 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }
if v.abs() <= 0.040_45 { v / 12.92 } else { v.signum() * ((v.abs() + 0.055) / 1.055).powf(2.4) }
});
let l = (0.412_221_470_8 * r + 0.536_332_536_3 * g + 0.051_445_992_9 * b).cbrt();
let m = (0.211_903_498_2 * r + 0.680_699_545_1 * g + 0.107_396_956_6 * b).cbrt();
+266
View File
@@ -0,0 +1,266 @@
//! OKLCH, the polar form of Oklab, as CSS Color 4 defines it
//! (<https://www.w3.org/TR/css-color-4/#specifying-oklab-oklch>): lightness L from 0 to 1, chroma
//! C (CSS reads 100% as 0.4) and hue H in degrees from the positive `a` axis. The conversions take
//! and give gamma-encoded sRGB through the Oklab matrices of [`crate::libraries`].
use crate::libraries::{oklab_to_linear_srgb, oklab_to_srgb, srgb_to_oklab};
/// The chroma CSS reads as 100%.
pub const CHROMA_FULL: f64 = 0.4;
/// Chroma at or below which the hue is powerless (CSS Color 4's ε); [`to_oklch`] gives hue 0 there.
pub const POWERLESS_CHROMA: f64 = 0.000_004;
/// How far outside 0..=1 an sRGB component may be and still count as inside the gamut.
const GAMUT_SLACK: f64 = 1e-4;
/// OKLCH `[l, c, h°]` of sRGB `rgb` (gamma encoded). Values outside 0..=1 are converted as they
/// are. The hue is in 0..360, and 0 while the chroma is powerless.
pub fn to_oklch(rgb: [f32; 3]) -> [f64; 3] {
let [l, a, b] = srgb_to_oklab(rgb);
let c = a.hypot(b);
if c <= POWERLESS_CHROMA {
return [l, 0.0, 0.0];
}
[l, c, b.atan2(a).to_degrees().rem_euclid(360.0)]
}
/// sRGB (gamma encoded) of OKLCH `(l, c, h°)`, unclamped.
pub fn oklch_to_srgb(l: f64, c: f64, h: f64) -> [f64; 3] {
let (sin, cos) = h.to_radians().sin_cos();
oklab_to_srgb(l, c * cos, c * sin)
}
/// Whether sRGB `rgb` lies inside the sRGB gamut.
pub fn in_srgb(rgb: [f64; 3]) -> bool {
rgb.iter().all(|v| (-GAMUT_SLACK..=1.0 + GAMUT_SLACK).contains(v))
}
/// The largest chroma sRGB holds at lightness `l` and hue `h°`: 0 at or outside black and white.
pub fn max_chroma(l: f64, h: f64) -> f64 {
largest_fitting_chroma(l, h, f64::INFINITY)
}
/// The largest chroma no more than `limit` that sRGB holds at lightness `l` and hue `h°`: 0 at or
/// outside black and white.
///
/// The chromas sRGB holds along the ray can come in several stretches: at the lightness and hue of
/// blue the ray leaves sRGB at a chroma of about 0.266 and comes back at blue itself, about 0.313,
/// and near black the gamut slack opens stretches of its own. Each linear sRGB channel is a cubic
/// in the chroma, so every stretch ends where a channel's cubic meets a bound of the gamut. The
/// search finds each such chroma between the cubic's turning points and takes the largest one that
/// fits.
fn largest_fitting_chroma(l: f64, h: f64, limit: f64) -> f64 {
if !(l > 0.0 && l < 1.0) || !h.is_finite() {
return 0.0;
}
let top = limit.min(0.5);
if top <= 0.0 {
return 0.0;
}
let fits = |c: f64| in_srgb(oklch_to_srgb(l, c, h));
if fits(top) {
return top;
}
let (sin, cos) = h.to_radians().sin_cos();
let lin = |c: f64| oklab_to_linear_srgb(l, c * cos, c * sin);
// The linear channels at chromas 0, s, 2s and 3s give each cubic's coefficients in t = c / s.
let s = top / 3.0;
let y = [lin(0.0), lin(s), lin(2.0 * s), lin(3.0 * s)];
let bounds = [-GAMUT_SLACK / 12.92, ((1.0 + GAMUT_SLACK + 0.055) / 1.055).powf(2.4)];
let mut ends = vec![0.0];
for ch in 0..3 {
let [y0, y1, y2, y3] = [y[0][ch], y[1][ch], y[2][ch], y[3][ch]];
let (d1, d2, d3) = (y1 - y0, y2 - 2.0 * y1 + y0, y3 - 3.0 * y2 + 3.0 * y1 - y0);
let k = [y0, d1 - d2 / 2.0 + d3 / 3.0, d2 / 2.0 - d3 / 2.0, d3 / 6.0];
let p = |t: f64| ((k[3] * t + k[2]) * t + k[1]) * t + k[0];
// The cubic rises or falls on each stretch between its turning points.
let mut cuts = vec![0.0, 3.0];
cuts.extend(turning_points(3.0 * k[3], 2.0 * k[2], k[1]).into_iter().filter(|t| *t > 0.0 && *t < 3.0));
cuts.sort_by(f64::total_cmp);
ends.extend(cuts.iter().map(|t| t * s));
for w in cuts.windows(2) {
for bound in bounds {
let (mut a, mut b) = (w[0], w[1]);
let fa = p(a) - bound;
if fa * (p(b) - bound) > 0.0 {
continue;
}
for _ in 0..60 {
let mid = (a + b) / 2.0;
if (p(mid) - bound) * fa > 0.0 { a = mid } else { b = mid }
}
ends.extend([a * s, b * s]);
}
}
}
ends.sort_by(|a, b| b.total_cmp(a));
ends.into_iter().flat_map(|c| [c, c - 1e-9]).find(|c| (0.0..=top).contains(c) && fits(*c)).unwrap_or(0.0)
}
/// The real roots of `a t² + b t + c`.
fn turning_points(a: f64, b: f64, c: f64) -> Vec<f64> {
if a.abs() < 1e-15 {
return if b.abs() < 1e-15 { Vec::new() } else { vec![-c / b] };
}
let disc = b * b - 4.0 * a * c;
if disc < 0.0 {
return Vec::new();
}
let r = disc.sqrt();
vec![(-b - r) / (2.0 * a), (-b + r) / (2.0 * a)]
}
/// The sRGB color (gamma encoded, 0..=1) of OKLCH `(l, c, h°)`, and whether its chroma was lowered:
/// a color outside sRGB keeps its lightness and hue and takes the largest chroma below it that
/// fits. Lightness is clamped to 0..=1 and chroma to 0 or more.
pub fn from_oklch(l: f64, c: f64, h: f64) -> ([f32; 3], bool) {
let l = if l.is_nan() { 0.0 } else { l.clamp(0.0, 1.0) };
let c = if c.is_nan() { 0.0 } else { c.max(0.0) };
let h = if h.is_finite() { h } else { 0.0 };
let exact = oklch_to_srgb(l, c, h);
let (rgb, lowered) = if in_srgb(exact) { (exact, false) } else { (oklch_to_srgb(l, largest_fitting_chroma(l, h, c), h), true) };
(rgb.map(|v| v.clamp(0.0, 1.0) as f32), lowered)
}
#[cfg(test)]
mod tests {
use super::*;
fn eight(rgb: [f32; 3]) -> [u8; 3] {
rgb.map(|v| (v * 255.0).round() as u8)
}
#[test]
fn red_has_the_oklch_of_the_oklab_matrices_and_converts_back() {
let [l, c, h] = to_oklch([1.0, 0.0, 0.0]);
assert!((l - 0.6280).abs() < 5e-5 && (c - 0.2577).abs() < 5e-5 && (h - 29.23).abs() < 5e-3, "{l} {c} {h}");
let (rgb, lowered) = from_oklch(l, c, h);
assert_eq!((eight(rgb), lowered), ([255, 0, 0], false));
}
/// CSS Color 4's examples convert to the hue its oklab() and oklch() forms give.
#[test]
fn the_polar_form_matches_the_css_examples() {
for ([l, a, b], [cl, cc, ch]) in
[([0.40101, 0.1147, 0.0453], [0.40101, 0.12332, 21.555]), ([0.65125, -0.0320, 0.1274], [0.65125, 0.13138, 104.097])]
{
let rgb = oklab_to_srgb(l, a, b).map(|v| v as f32);
let [ol, oc, oh] = to_oklch(rgb);
assert!((ol - cl).abs() < 1e-4 && (oc - cc).abs() < 1e-4 && (oh - ch).abs() < 0.05, "{ol} {oc} {oh}");
}
}
#[test]
fn the_216_web_colors_round_trip() {
let steps = [0u8, 0x33, 0x66, 0x99, 0xcc, 0xff];
for r in steps {
for g in steps {
for b in steps {
let rgb = [r, g, b].map(|v| f32::from(v) / 255.0);
let [l, c, h] = to_oklch(rgb);
assert_eq!(eight(from_oklch(l, c, h).0), [r, g, b], "{l} {c} {h}");
}
}
}
}
#[test]
fn grays_have_no_chroma_and_hue_zero() {
for v in [0.0, 0.5, 1.0] {
let [_, c, h] = to_oklch([v, v, v]);
assert!(c <= POWERLESS_CHROMA && h == 0.0, "{c} {h}");
}
}
/// A chroma past the gamut gives a color inside it with the same lightness and hue, and says so.
#[test]
fn a_chroma_past_the_gamut_is_lowered_keeping_lightness_and_hue() {
let (l, h) = (0.7, 150.0);
let max = max_chroma(l, h);
assert!(max > 0.05 && max < CHROMA_FULL, "{max}");
assert!(in_srgb(oklch_to_srgb(l, max, h)) && !in_srgb(oklch_to_srgb(l, max + 1e-3, h)));
let (rgb, lowered) = from_oklch(l, CHROMA_FULL, h);
assert!(lowered);
let [ol, oc, oh] = to_oklch(rgb);
assert!((ol - l).abs() < 2e-3 && (oh - h).abs() < 1.0 && (oc - max).abs() < 2e-3, "{ol} {oc} {oh}");
assert!(!from_oklch(l, max * 0.5, h).1);
}
/// At the lightness and hue of blue the ray leaves sRGB and comes back at blue itself, so the
/// largest chroma is blue's, and a chroma past it gives blue.
#[test]
fn the_largest_chroma_at_blues_hue_is_blues() {
let [l, c, h] = to_oklch([0.0, 0.0, 1.0]);
let max = max_chroma(l, h);
assert!((max - c).abs() < 1e-4 && in_srgb(oklch_to_srgb(l, max, h)), "{max} {c}");
let (rgb, lowered) = from_oklch(l, CHROMA_FULL, h);
assert_eq!((eight(rgb), lowered), ([0, 0, 255], true));
// A chroma between the two stretches takes the end of the first one, inside sRGB.
let (rgb, lowered) = from_oklch(l, 0.29, h);
let [_, gc, _] = to_oklch(rgb);
assert!(lowered && gc < 0.27 && in_srgb(oklch_to_srgb(l, gc, h)), "{gc}");
// A hue just past blue's: a narrow second stretch ends just below the line from black to blue.
let (l, h) = (0.44, 264.06);
let max = max_chroma(l, h);
assert!(max > 0.304 && max < 0.305 && in_srgb(oklch_to_srgb(l, max, h)), "{max}");
let [_, got, _] = to_oklch(from_oklch(l, 0.35, h).0);
assert!(got > 0.303, "{got}");
// A darker blue on the line from black to blue.
let [l, c, h] = to_oklch([0.0, 0.0, 0.25]);
assert!((max_chroma(l, h) - c).abs() < 1e-4, "{} {c}", max_chroma(l, h));
}
/// Just below blue's lightness the line from black to blue passes a chroma of 0.3125, where a
/// search from 0 to 0.5 lands first. A chroma asked for below that line still gives a color
/// inside sRGB with the lightness and hue asked for.
#[test]
fn a_chroma_below_the_line_from_black_to_blue_stays_inside_srgb() {
let [bl, bc, h] = to_oklch([0.0, 0.0, 1.0]);
let l = bl * 0.3125 / bc;
let (rgb, lowered) = from_oklch(l, 0.29, h);
let [gl, gc, gh] = to_oklch(rgb);
assert!(lowered && gc < 0.29 && in_srgb(oklch_to_srgb(l, gc, h)), "{gc}");
assert!((gl - l).abs() < 2e-3 && (gh - h).abs() < 1.0, "{gl} {gh}");
}
/// sRGB channels below 0 go through the transfer curve with its sign turned, as CSS Color 4's
/// extended sRGB does, in both directions.
#[test]
fn negative_channels_use_the_signed_transfer_curve() {
let linear = -((0.5_f64 + 0.055) / 1.055).powf(2.4);
let [l, c, _] = to_oklch([-0.5; 3]);
assert!((l - linear.cbrt()).abs() < 1e-4 && c <= POWERLESS_CHROMA, "{l} {c}");
for v in oklch_to_srgb(linear.cbrt(), 0.0, 0.0) {
assert!((v + 0.5).abs() < 1e-4, "{v}");
}
// Small values near 0 keep the straight part of the curve.
let [l, _, _] = to_oklch([-0.01; 3]);
assert!((l - (-0.01_f64 / 12.92).cbrt()).abs() < 1e-4, "{l}");
}
/// The largest chroma fits and is at least the largest one a scan in steps of 0.0005 finds, at
/// every hue and at lightnesses near black too, where the ray can come back into sRGB away from
/// any primary color's hue (L 0.02 and H 242° fit up to about 0.022 after leaving near 0.012).
#[test]
fn the_largest_chroma_is_never_below_a_scan_of_the_ray() {
let scan = |l: f64, h: f64| (0..=1000).map(|i| f64::from(i) * 0.0005).filter(|c| in_srgb(oklch_to_srgb(l, *c, h))).fold(0.0, f64::max);
assert!(max_chroma(0.02, 242.0) > 0.02, "{}", max_chroma(0.02, 242.0));
for l in [0.005, 0.02, 0.05, 0.1, 0.3, 0.44, 0.6, 0.8, 0.95, 0.99] {
for h in (0..72).map(|i| f64::from(i) * 5.0 + 2.0) {
let max = max_chroma(l, h);
assert!(in_srgb(oklch_to_srgb(l, max, h)) && max >= scan(l, h), "L {l} H {h}: {max} < {}", scan(l, h));
}
}
}
#[test]
fn black_white_and_bad_numbers_hold_no_chroma() {
assert_eq!(max_chroma(0.0, 30.0), 0.0);
assert_eq!(max_chroma(1.0, 30.0), 0.0);
assert_eq!(max_chroma(f64::NAN, 30.0), 0.0);
assert_eq!(max_chroma(0.5, f64::INFINITY), 0.0);
assert_eq!(eight(from_oklch(f64::NAN, f64::NAN, f64::NAN).0), [0, 0, 0]);
assert_eq!(eight(from_oklch(2.0, -1.0, 0.0).0), [255, 255, 255]);
}
}
+48
View File
@@ -1156,6 +1156,17 @@ impl Lerp {
(NodeKind::PlacedDocument(o), NodeKind::PlacedDocument(x), NodeKind::PlacedDocument(y)) => o.xf = lerp_affine(x.xf, y.xf, t),
_ => {}
}
// Between distorted images, each step's corners lie between the keys' corners. A
// step whose corners would fold keeps the nearer key's.
if (a.is_distorted_image() || b.is_distorted_image())
&& let (Some(qa), Some(qb)) = (a.image_corners(), b.image_corners())
{
let near = if t < 0.5 { qa } else { qb };
if n.set_image_corners([0, 1, 2, 3].map(|i| qa[i].lerp(qb[i], t))).is_err() {
// The nearer key's corners passed the same check when it was distorted.
let _ = n.set_image_corners(near);
}
}
n.extras_mut().mask = None;
n
}
@@ -2297,6 +2308,43 @@ mod tests {
assert_eq!(m.subpaths[0].anchors[0].p, Point::new(55.0, 0.0));
}
/// A step between two distorted images has its corners between the keys' corners.
#[test]
fn steps_between_distorted_images_have_corners_between_theirs() {
let image = |q: [(f64, f64); 4]| {
let im = crate::ImageObject {
key: "k".into(),
width: 10,
height: 10,
xf: Affine::IDENTITY,
link: None,
placement: Default::default(),
pixels: None,
};
let mut n = Node::new(NodeId(1), NodeKind::Image(Box::new(im)));
n.set_image_corners(q.map(|(x, y)| Point::new(x, y))).unwrap();
n
};
let a = image([(40.0, 0.0), (60.0, 0.0), (100.0, 100.0), (0.0, 100.0)]);
let b = image([(200.0, 0.0), (300.0, 0.0), (280.0, 100.0), (220.0, 100.0)]);
let mid = Lerp::new(&a, &b, (None, None)).at(0.5);
let want = [(120.0, 0.0), (180.0, 0.0), (190.0, 100.0), (110.0, 100.0)];
let got = mid.image_corners().unwrap();
for (g, (x, y)) in got.iter().zip(want) {
assert!(g.distance(Point::new(x, y)) < 1e-9, "{got:?}");
}
// Toward a key flipped left to right, the middle step's corners would meet: each step
// there keeps the nearer key's corners, whether that key is distorted or not.
let flipped = image([(60.0, 0.0), (40.0, 0.0), (0.0, 100.0), (100.0, 100.0)]);
let mirror = image([(100.0, 0.0), (0.0, 0.0), (0.0, 100.0), (100.0, 100.0)]);
assert!(!mirror.is_distorted_image());
for (b, t) in [(&flipped, 0.5), (&mirror, 0.5), (&mirror, 0.45)] {
let got = Lerp::new(&a, b, (None, None)).at(t).image_corners().unwrap();
let near = (if t < 0.5 { &a } else { b }).image_corners().unwrap();
assert!(got.iter().zip(near).all(|(g, w)| g.distance(w) < 1e-9), "{t}: {got:?} against {near:?}");
}
}
fn key(x: f64) -> Arc<Node> {
Arc::new(Node::path(NodeId(1), vectorcraft_geom::shapes::rectangle(Rect::new(x, 0.0, x + 10.0, 10.0)), Appearance::default()))
}
+62
View File
@@ -500,11 +500,73 @@ impl Document {
self.patterns.iter_mut().find(|p| p.name == name)
}
/// The [`Self::unknown`] key that holds each symbol set's Symbol Set Density, `{set id: density}`.
/// [`Self::reid`] gives a copy of a set in this document the density recorded for its source, and
/// [`Self::carry_set_densities`] gives a pasted set the density recorded for it at Copy.
pub const SYMBOL_SET_DENSITY_KEY: &'static str = "symbolSetDensity";
/// The Symbol Set Densities recorded for `nodes` and their descendants, by id.
pub fn set_densities_of(&self, nodes: &[Node]) -> std::collections::BTreeMap<NodeId, serde_json::Value> {
let Some(serde_json::Value::Object(record)) = self.unknown.get(Self::SYMBOL_SET_DENSITY_KEY) else { return Default::default() };
let mut out = std::collections::BTreeMap::new();
let mut stack: Vec<&Node> = nodes.iter().collect();
while let Some(n) = stack.pop() {
if let Some(v) = record.get(&n.id.0.to_string()) {
out.insert(n.id, v.clone());
}
stack.extend(n.children().into_iter().flatten().map(|c| &**c));
}
out
}
/// Record for `copy`, a [`Self::reid`] copy of `source`, and its descendants the Symbol Set
/// Densities that `densities` holds for `source` and its descendants, and none for those it
/// holds none for (whatever [`Self::reid`] recorded).
pub fn carry_set_densities(&mut self, source: &Node, copy: &Node, densities: &std::collections::BTreeMap<NodeId, serde_json::Value>) {
if densities.is_empty() && !self.unknown.contains_key(Self::SYMBOL_SET_DENSITY_KEY) {
return;
}
let mut pairs = vec![(source, copy)];
while let Some((s, c)) = pairs.pop() {
match densities.get(&s.id) {
Some(v) => {
if let serde_json::Value::Object(m) =
self.unknown.entry(Self::SYMBOL_SET_DENSITY_KEY).or_insert_with(|| serde_json::Value::Object(Default::default()))
{
m.insert(c.id.0.to_string(), v.clone());
}
}
None => {
if let Some(serde_json::Value::Object(m)) = self.unknown.get_mut(Self::SYMBOL_SET_DENSITY_KEY) {
m.remove(&c.id.0.to_string());
}
}
}
if let (Some(sc), Some(cc)) = (s.children(), c.children()) {
pairs.extend(sc.iter().zip(cc.iter()).map(|(a, b)| (&**a, &**b)));
}
}
}
/// Deep-clone `node` with fresh ids for it and all descendants, its images' own pixels taken
/// in ([`Self::adopt_pixels`]).
pub fn reid(&mut self, node: &Node) -> Node {
let mut n = node.clone();
n.id = self.alloc_id();
// A copy of a symbol set keeps the Symbol Set Density recorded for its source, when the source
// is this document's node with that id; a node from another document may share the id of an
// unrelated set here.
let density = self
.unknown
.get(Self::SYMBOL_SET_DENSITY_KEY)
.and_then(|m| m.get(node.id.0.to_string()))
.filter(|_| self.node(node.id) == Some(node))
.cloned();
if let Some(v) = density
&& let Some(serde_json::Value::Object(m)) = self.unknown.get_mut(Self::SYMBOL_SET_DENSITY_KEY)
{
m.insert(n.id.0.to_string(), v);
}
if let NodeKind::Image(im) = &mut n.kind {
self.adopt_image_pixels(im);
}
+8 -5
View File
@@ -1503,14 +1503,17 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
// An image is hit within its frame (on the frame's edge only with Selection by Path Only,
// #3291, and in outline mode where the frame is all that is drawn, #6437), and where its
// own fills and strokes paint ([`image_paint`]) except in outline mode.
NodeKind::Image(im) => {
NodeKind::Image(_) => {
// The frame joins the image's corners ([`Node::image_frame`]); a plain image is picked
// inside by its bounds, without building it.
if opt.path_only || (opt.outline && !symbols.document().setup.outline_images) {
use vectorcraft_geom::kurbo::Shape;
let mut frame = Rect::new(0.0, 0.0, f64::from(im.width), f64::from(im.height)).to_path(0.1);
frame.apply_affine(im.xf);
if stroke_contains(&frame, 0.0, opt.tol, p) {
if n.image_frame().is_some_and(|frame| stroke_contains(&frame, 0.0, opt.tol, p)) {
return Some(HitKind::Outline);
}
} else if let Some(frame) = n.is_distorted_image().then(|| n.image_frame()).flatten() {
if fill_contains(&frame, FillRule::NonZero, p) || stroke_contains(&frame, 0.0, opt.tol, p) {
return Some(HitKind::Bounds);
}
} else if n.geometric_bounds_with(symbols).is_some_and(|b| b.inflate(opt.tol, opt.tol).contains(p)) {
return Some(HitKind::Bounds);
}
+599
View File
@@ -0,0 +1,599 @@
//! Perspective Distort and Free Distort on an image: its pixel rectangle's corners placed anywhere
//! on the page, as long as they make a strictly convex quadrilateral.
//!
//! An image whose corners make a parallelogram is placed by its transform alone
//! ([`crate::ImageObject::xf`]). Other corners are kept in the image's extras
//! ([`crate::NodeExtras::image_quad`]), and the image is then drawn through the projective map
//! that takes its pixel rectangle to them. The renderer, the exporters and printing draw it as a
//! raster mesh warp ([`crate::live::mesh_warp_image`]) made from that map ([`distorted_art`]): no
//! warped copy of the pixels is kept. The quad stays with the image's transform: moving, scaling,
//! rotating or shearing the image maps its corners too ([`crate::Node::transform`]).
//!
//! The convexity rule, the tolerance of the mesh and its cell limit are VectorCraft's own.
use std::sync::Arc;
use vectorcraft_geom::kurbo::BezPath;
use vectorcraft_geom::{Affine, Homography, PathData, Point, Rect, SubPath};
use crate::{Appearance, ImageObject, Node, NodeKind};
/// Most cells along each side of the mesh an image is drawn with ([`cells`]).
pub const MAX_CELLS: usize = 64;
/// The cells along each side an image with fewer pixels than this may still take ([`cells`]).
pub const MIN_CELL_CAP: usize = 8;
/// How far (in points) the mesh an image is drawn with in files and print may stray from the exact
/// projective map ([`Density::PAGE`]).
pub const TOLERANCE: f64 = 0.05;
/// How finely [`distorted_art_at`] cuts a distorted image ([`cells`]), and how far each piece
/// reaches into its neighbors. A pixel inside the image draws opaque only when one piece covers
/// it whole, so pieces much smaller than a pixel would let the page show through.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Density {
/// How far (in points) the mesh may stray from the exact projective map.
pub tolerance: f64,
/// The shortest a cell may be along the longest side of the corners, in points.
pub min_cell: f64,
/// How far (in points) each piece reaches past its triangle.
pub overlap: f64,
}
impl Density {
/// For files and print, whose viewing size is not known: within [`TOLERANCE`], cells of at
/// least 2 pt, and pieces that reach half a point past their triangles.
pub const PAGE: Density = Density { tolerance: TOLERANCE, min_cell: 2.0, overlap: 0.5 };
/// For drawing at `scale` device pixels a point: within a quarter of a pixel, cells of at least
/// 4 pixels, and pieces that reach 2 pixels past their triangles.
pub fn at_scale(scale: f64) -> Density {
let s = if scale.is_finite() && scale > 1e-6 { scale } else { 1.0 };
Density { tolerance: 0.25 / s, min_cell: 4.0 / s, overlap: 2.0 / s }
}
/// [`Density::PAGE`] for art that is drawn `scale` times its size (a symbol's art in an
/// instance that scales it): the tolerance, the cell size and the overlap measured on the page.
pub fn page_at(scale: f64) -> Density {
let s = if scale.is_finite() && scale > 1e-6 { scale } else { 1.0 };
let p = Density::PAGE;
Density { tolerance: p.tolerance / s, min_cell: p.min_cell / s, overlap: p.overlap / s }
}
}
/// How much `a` stretches its most stretched direction: the larger singular value of its linear
/// part.
pub fn max_stretch(a: Affine) -> f64 {
let [m0, m1, m2, m3, _, _] = a.as_coeffs();
let sum = m0 * m0 + m1 * m1 + m2 * m2 + m3 * m3;
let det = m0 * m3 - m1 * m2;
((sum + (sum * sum - 4.0 * det * det).max(0.0).sqrt()) / 2.0).sqrt()
}
/// Why corners cannot be an image's.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum QuadError {
/// A corner is not a finite point.
NotFinite,
/// The corners fold over, meet, or lie on one line: the quadrilateral is not strictly convex.
NotConvex,
/// The corners are convex but so close to a line that the perspective map through them cannot
/// place every corner.
TooNarrow,
}
impl std::fmt::Display for QuadError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
Self::NotFinite => "the corners of a distorted image must be finite points",
Self::NotConvex => "the corners of a distorted image must make a convex shape: an image cannot fold over itself or collapse to a line",
Self::TooNarrow => "the corners of a distorted image are too close together for a perspective map",
})
}
}
/// `im`'s pixel rectangle: (0, 0) to its width and height.
fn pixel_rect(im: &ImageObject) -> Rect {
Rect::new(0.0, 0.0, f64::from(im.width), f64::from(im.height))
}
/// The corners of `r` in the order a quad keeps them: top left, top right, bottom right, bottom
/// left.
fn rect_corners(r: Rect) -> [Point; 4] {
[Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)]
}
/// Whether the corners `q` (in order around the shape) are finite and make a strictly convex
/// quadrilateral, turning either way round. Each turn must be larger than 1e-9 times the product
/// of the two sides it joins, a test that gives the same answer at any scale.
pub fn check(q: &[Point; 4]) -> Result<(), QuadError> {
if q.iter().any(|p| !p.is_finite()) {
return Err(QuadError::NotFinite);
}
let mut sign = 0.0;
for i in 0..4 {
let (a, b, c) = (q[i], q[(i + 1) % 4], q[(i + 2) % 4]);
let (u, v) = (b - a, c - b);
let cross = u.cross(v);
let scale = u.hypot() * v.hypot();
if !cross.is_finite() || !scale.is_finite() || cross.abs() <= 1e-9 * scale || scale == 0.0 {
return Err(QuadError::NotConvex);
}
if sign == 0.0 {
sign = cross.signum();
} else if cross.signum() != sign {
return Err(QuadError::NotConvex);
}
}
// Four turns the same way round can still wind twice (a star); a convex quadrilateral's
// diagonals cross.
let crosses = |a: Point, b: Point, c: Point, d: Point| (b - a).cross(c - a).signum() != (b - a).cross(d - a).signum();
if !crosses(q[0], q[2], q[1], q[3]) || !crosses(q[1], q[3], q[0], q[2]) {
return Err(QuadError::NotConvex);
}
Ok(())
}
/// Whether `q` can be image `im`'s corners: [`check`], and either a parallelogram or corners the
/// perspective map from its pixels ([`pixel_map`]) places, each within a millionth of `q`'s
/// shortest side plus the rounding error of coordinates as far from the origin as `q`'s.
pub fn check_for(im: &ImageObject, q: &[Point; 4]) -> Result<(), QuadError> {
check(q)?;
if parallelogram(im, q).is_some() {
return Ok(());
}
let tol = placement_tolerance(q);
let map = pixel_map(im, q);
let placed = rect_corners(pixel_rect(im)).iter().zip(q).all(|(c, want)| map.apply(*c).is_some_and(|p| p.distance(*want) <= tol));
if placed { Ok(()) } else { Err(QuadError::TooNarrow) }
}
/// How far a map may place a corner from `q`'s: a millionth of `q`'s shortest side plus the
/// rounding error of coordinates as far from the origin as `q`'s.
fn placement_tolerance(q: &[Point; 4]) -> f64 {
let side = (0..4).map(|i| q[i].distance(q[(i + 1) % 4])).fold(f64::INFINITY, f64::min);
let far = q.iter().map(|p| p.x.abs().max(p.y.abs())).fold(0.0, f64::max);
side * 1e-6 + far * 1e-12
}
/// The affine map from `im`'s pixel space that places its corners at `q`, when `q` is a
/// parallelogram (within 1e-9 of the quad's size): the map puts the fourth corner within
/// [`placement_tolerance`] of `q`'s. `None` otherwise.
fn parallelogram(im: &ImageObject, q: &[Point; 4]) -> Option<Affine> {
let size = q.iter().fold(0.0_f64, |m, p| m.max((*p - q[0]).hypot()));
// The affine map through the other three corners misses the bottom right one by this much.
let gap = (q[0].to_vec2() + q[2].to_vec2() - q[1].to_vec2() - q[3].to_vec2()).hypot();
if gap > 1e-9 * size || gap > placement_tolerance(q) {
return None;
}
let (w, h) = (f64::from(im.width.max(1)), f64::from(im.height.max(1)));
let (x, y) = ((q[1] - q[0]) / w, (q[3] - q[0]) / h);
let a = Affine::new([x.x, x.y, y.x, y.y, q[0].x, q[0].y]);
a.is_finite().then_some(a)
}
/// The homography taking the unit square's corners (0,0), (1,0), (1,1), (0,1) to `q`.
fn square_to(q: &[Point; 4]) -> Homography {
let [p0, p1, p2, p3] = *q;
let (sx, sy) = (p0.x - p1.x + p2.x - p3.x, p0.y - p1.y + p2.y - p3.y);
let (dx1, dx2, dy1, dy2) = (p1.x - p2.x, p3.x - p2.x, p1.y - p2.y, p3.y - p2.y);
let den = dx1 * dy2 - dx2 * dy1;
let (g, h) = if den.abs() < 1e-300 { (0.0, 0.0) } else { ((sx * dy2 - dx2 * sy) / den, (dx1 * sy - sx * dy1) / den) };
Homography([[p1.x - p0.x + g * p1.x, p3.x - p0.x + h * p3.x, p0.x], [p1.y - p0.y + g * p1.y, p3.y - p0.y + h * p3.y, p0.y], [g, h, 1.0]])
}
impl Node {
/// This image's distortion: where its pixel rectangle's corners stand (top left, top right,
/// bottom right, bottom left) when they do not make a parallelogram. `None` for an image placed
/// by its transform alone, for anything that is not an image, and for corners a file holds
/// that [`check_for`] refuses (the image is then placed by its transform).
pub fn image_quad(&self) -> Option<[Point; 4]> {
let NodeKind::Image(im) = &self.kind else { return None };
let q = **self.extras().image_quad.as_ref()?;
check_for(im, &q).is_ok().then_some(q)
}
/// Whether this is an image with a distortion ([`Self::image_quad`]).
pub fn is_distorted_image(&self) -> bool {
self.image_quad().is_some()
}
/// Where this image's pixel rectangle's corners stand: its distortion, or its transform's
/// corners. `None` for anything that is not an image.
pub fn image_corners(&self) -> Option<[Point; 4]> {
let NodeKind::Image(im) = &self.kind else { return None };
Some(self.image_quad().unwrap_or_else(|| rect_corners(pixel_rect(im)).map(|p| im.xf * p)))
}
/// Place this image's corners at `q` (top left, top right, bottom right, bottom left): by its
/// transform when they make a parallelogram (and the distortion is cleared), else as its
/// distortion. An error, and nothing changes, when `q` fails [`check_for`] or this is not an
/// image.
pub fn set_image_corners(&mut self, q: [Point; 4]) -> Result<(), QuadError> {
let NodeKind::Image(im) = &mut self.kind else { return Err(QuadError::NotConvex) };
check_for(im, &q)?;
match parallelogram(im, &q) {
Some(xf) => {
im.xf = xf;
if self.extras().image_quad.is_some() {
self.extras_mut().image_quad = None;
}
}
None => self.extras_mut().image_quad = Some(Box::new(q)),
}
Ok(())
}
/// The outline of this image's frame on the page: its corners joined by straight lines.
/// `None` for anything that is not an image.
pub fn image_frame(&self) -> Option<BezPath> {
let q = self.image_corners()?;
let mut bp = BezPath::new();
bp.move_to(q[0]);
for p in &q[1..] {
bp.line_to(*p);
}
bp.close_path();
Some(bp)
}
/// The map from this image's pixel space to the page: projective for a distorted image, its
/// transform otherwise. `None` for anything that is not an image.
pub fn image_map(&self) -> Option<Homography> {
let NodeKind::Image(im) = &self.kind else { return None };
Some(match self.image_quad() {
Some(q) => pixel_map(im, &q),
None => Homography::from_affine(im.xf),
})
}
}
/// The projective map from `im`'s pixel space to the page that puts its corners at `q`.
fn pixel_map(im: &ImageObject, q: &[Point; 4]) -> Homography {
let (w, h) = (f64::from(im.width.max(1)), f64::from(im.height.max(1)));
square_to(q).then_after(&Homography::from_affine(Affine::scale_non_uniform(1.0 / w, 1.0 / h)))
}
/// How many cells along each side the mesh of a distorted image takes: the fewest (a power of two
/// up to [`MAX_CELLS`]) for which the mesh's triangles, each mapped by the affine map through its
/// corners, stay within `density`'s tolerance of `map` at the middle of every cell and every cell
/// side. An image takes no more cells than it has pixels along its longer side, or
/// [`MIN_CELL_CAP`] when that is more, and no more than leave each cell `density.min_cell` along
/// the longest side of its corners. A perspective that needs more cells than these limits allow is
/// drawn with the cells they allow.
pub fn cells(map: &Homography, im: &ImageObject, density: Density) -> usize {
let (w, h) = (f64::from(im.width.max(1)), f64::from(im.height.max(1)));
let corners = [Point::new(0.0, 0.0), Point::new(w, 0.0), Point::new(w, h), Point::new(0.0, h)].map(|p| map.apply(p));
let longest =
corners.iter().zip(corners.iter().cycle().skip(1)).filter_map(|(a, b)| Some(a.as_ref()?.distance(*b.as_ref()?))).fold(0.0, f64::max);
let by_size = longest / density.min_cell;
let by_size = if by_size.is_finite() { (by_size as usize).max(1) } else { MAX_CELLS };
let most = MAX_CELLS.min((im.width.max(im.height) as usize).max(MIN_CELL_CAP)).min(by_size);
let at = |x: f64, y: f64| map.apply(Point::new(x, y));
let mut k = 1;
while k < most {
let fits = (0..k * k).all(|c| {
let (i, j) = ((c % k) as f64, (c / k) as f64);
let (x0, y0, x1, y1) = (w * i / k as f64, h * j / k as f64, w * (i + 1.0) / k as f64, h * (j + 1.0) / k as f64);
let (Some(a), Some(b), Some(cc), Some(d)) = (at(x0, y0), at(x1, y0), at(x1, y1), at(x0, y1)) else { return false };
let near = |exact: Option<Point>, m: Point| exact.is_some_and(|e| e.distance(m) <= density.tolerance);
near(at((x0 + x1) / 2.0, (y0 + y1) / 2.0), a.midpoint(cc))
&& near(at((x0 + x1) / 2.0, y0), a.midpoint(b))
&& near(at(x1, (y0 + y1) / 2.0), b.midpoint(cc))
&& near(at((x0 + x1) / 2.0, y1), d.midpoint(cc))
&& near(at(x0, (y0 + y1) / 2.0), a.midpoint(d))
});
if fits {
break;
}
k *= 2;
}
k.min(most)
}
/// For a format that cannot clip an image into the pieces of [`distorted_art`]: the affine
/// placement nearest distorted image `n`'s projective map, the one that matches it at the middle
/// of its pixels. `None` when `n` is not a distorted image.
pub fn nearest_affine(n: &Node) -> Option<Affine> {
let NodeKind::Image(im) = &n.kind else { return None };
let q = n.image_quad()?;
pixel_map(im, &q).affine_at(pixel_rect(im).center())
}
/// Distorted image `n` as the art that draws it in files and print: [`distorted_art_at`] with
/// [`Density::PAGE`].
pub fn distorted_art(n: &Node) -> Option<Node> {
distorted_art_at(n, Density::PAGE)
}
/// Distorted image `n` as the art that draws it: a clip group, clipped by its corners, around the
/// raster mesh warp ([`crate::live::mesh_warp_image`]) of its pixels through its projective map,
/// with [`cells`] cells along each side for `density` and each piece reaching `density.overlap`
/// past its triangle. The art has `n`'s id but not its name and transparency (which the caller
/// keeps on the object around the art). `None` when `n` is not a distorted image.
pub fn distorted_art_at(n: &Node, density: Density) -> Option<Node> {
let NodeKind::Image(im) = &n.kind else { return None };
let q = n.image_quad()?;
let map = pixel_map(im, &q);
let k = cells(&map, im, density);
let mut plain = n.clone();
// Whether the image shows is the image's to decide: a hidden source image that a view draws
// anyway (Image Trace's Source Image) draws its art.
plain.visible = true;
// The image's own fills and strokes paint by the image's rules, not on the mesh's group.
plain.appearance = Default::default();
plain.name = None;
plain.opacity = 1.0;
plain.blend = Default::default();
plain.isolate = false;
plain.knockout = Default::default();
plain.knockout_shape = false;
if let Some(e) = plain.extras_if_any() {
e.mask = None;
}
let mut art = crate::live::mesh_warp_image_with(&plain, im, &|p| p, k, n.extras().pixelated, false, Some(density.overlap));
// The pieces along the image's edges reach past its corners too: the corners clip them.
let mut edge = Node::path(n.id, PathData::single(SubPath::polyline(&q, true)), Appearance::default());
if let NodeKind::Path { clipping, .. } = &mut edge.kind {
*clipping = true;
}
let pieces = std::mem::replace(&mut art.kind, NodeKind::Group { children: vec![], clip: true });
let mut mesh = art.clone();
mesh.kind = pieces;
art.knockout = Default::default();
art.kind = NodeKind::Group { children: vec![Arc::new(edge), Arc::new(mesh)], clip: true };
Some(art)
}
/// The pieces of [`distorted_art_at`]'s art: the children of its mesh group.
pub fn distorted_pieces(art: &Node) -> &[Arc<Node>] {
art.children().and_then(|c| c.get(1)).and_then(|m| m.children()).map_or(&[], Vec::as_slice)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::NodeId;
fn image(w: u32, h: u32) -> Node {
let im = ImageObject { key: "k".into(), width: w, height: h, xf: Affine::IDENTITY, link: None, placement: Default::default(), pixels: None };
Node::new(NodeId(1), NodeKind::Image(Box::new(im)))
}
fn pts(v: [(f64, f64); 4]) -> [Point; 4] {
v.map(|(x, y)| Point::new(x, y))
}
#[test]
fn a_convex_quad_either_way_round_passes_and_a_fold_or_line_does_not() {
assert_eq!(check(&pts([(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)])), Ok(()));
assert_eq!(check(&pts([(0.0, 0.0), (0.0, 10.0), (10.0, 10.0), (10.0, 0.0)])), Ok(()));
// Two corners swapped: the sides cross.
assert_eq!(check(&pts([(0.0, 0.0), (10.0, 0.0), (0.0, 10.0), (10.0, 10.0)])), Err(QuadError::NotConvex));
// A dent.
assert_eq!(check(&pts([(0.0, 0.0), (10.0, 0.0), (2.0, 2.0), (0.0, 10.0)])), Err(QuadError::NotConvex));
// Three on a line, and two corners at one point.
assert_eq!(check(&pts([(0.0, 0.0), (5.0, 0.0), (10.0, 0.0), (0.0, 10.0)])), Err(QuadError::NotConvex));
assert_eq!(check(&pts([(0.0, 0.0), (0.0, 0.0), (10.0, 10.0), (0.0, 10.0)])), Err(QuadError::NotConvex));
assert_eq!(check(&pts([(f64::NAN, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)])), Err(QuadError::NotFinite));
}
/// A convex quad with one edge so short that the perspective map through it cannot place the
/// other corners: refused when set, and a file's copy of it leaves the image undistorted.
#[test]
fn corners_the_perspective_map_cannot_place_are_refused() {
let q = pts([(50.0, 0.0), (50.000000005, 0.0), (100.0, 100.0), (0.0, 100.0)]);
assert_eq!(check(&q), Ok(()));
let mut n = image(100, 100);
assert_eq!(n.set_image_corners(q), Err(QuadError::TooNarrow));
assert!(n.extras().image_quad.is_none());
n.extras_mut().image_quad = Some(Box::new(q));
assert_eq!(n.image_quad(), None);
assert!(distorted_art(&n).is_none());
assert_eq!(n.image_corners(), Some(rect_corners(Rect::new(0.0, 0.0, 100.0, 100.0))));
}
#[test]
fn a_parallelogram_goes_into_the_transform_and_other_corners_into_the_quad() {
let mut n = image(100, 50);
n.set_image_corners(pts([(10.0, 0.0), (110.0, 10.0), (100.0, 60.0), (0.0, 50.0)])).unwrap();
assert_eq!(n.image_quad(), None);
let NodeKind::Image(im) = &n.kind else { panic!("an image") };
assert!((im.xf * Point::new(100.0, 50.0)).distance(Point::new(100.0, 60.0)) < 1e-9);
let q = pts([(40.0, 0.0), (60.0, 0.0), (100.0, 100.0), (0.0, 100.0)]);
n.set_image_corners(q).unwrap();
assert_eq!(n.image_quad(), Some(q));
assert_eq!(n.image_corners(), Some(q));
let map = n.image_map().unwrap();
for (c, want) in rect_corners(Rect::new(0.0, 0.0, 100.0, 50.0)).iter().zip(q) {
assert!(map.apply(*c).unwrap().distance(want) < 1e-9, "{c:?}");
}
// Back to a rectangle: the quad is cleared.
n.set_image_corners(pts([(0.0, 0.0), (100.0, 0.0), (100.0, 50.0), (0.0, 50.0)])).unwrap();
assert!(n.extras().image_quad.is_none());
}
/// Corners whose gap from a parallelogram is tiny next to the quad's size but not next to its
/// shortest side stay a distortion: the affine map would put the bottom right corner twice as
/// low as asked.
#[test]
fn corners_the_affine_map_misses_stay_a_distortion() {
let mut n = image(100, 100);
let q = pts([(0.0, 0.0), (100000.0, 0.0), (100000.0, 0.00005), (0.0, 0.0001)]);
n.set_image_corners(q).unwrap();
assert_eq!(n.image_quad(), Some(q));
let map = n.image_map().unwrap();
for (c, want) in rect_corners(Rect::new(0.0, 0.0, 100.0, 100.0)).iter().zip(q) {
assert!(map.apply(*c).unwrap().distance(want) < 1e-9, "{c:?}");
}
}
/// A scale that squeezes valid corners past what a perspective map can place leaves the image
/// at the placement nearest them, scaled, not at the rectangle it had before.
#[test]
fn a_scale_past_the_perspective_limit_keeps_the_nearest_placement() {
let mut n = image(100, 100);
n.set_image_corners(pts([(0.0, 0.0), (100.0, 0.0), (200.0, 2e-7), (0.0, 2e-7)])).unwrap();
assert!(n.is_distorted_image());
n.transform(Affine::scale_non_uniform(1.0, 0.25), false);
assert!(n.extras().image_quad.is_none());
let b = n.geometric_bounds().unwrap();
assert!(b.height() < 1e-6 && (b.width() - 150.0).abs() < 60.0, "{b:?}");
}
/// A file's corners that the image cannot take are dropped as it is read, so a later scale
/// that would make them valid leaves the image placed by its transform; a list of three
/// points is dropped too, and the rest of the image is read.
#[test]
fn corners_a_file_holds_that_are_refused_or_not_four_are_dropped_as_it_is_read() {
let mut n = image(100, 100);
n.extras_mut().image_quad = Some(Box::new(pts([(0.0, 0.0), (100.0, 0.0), (200.0, 5e-8), (0.0, 5e-8)])));
assert_eq!(n.image_quad(), None);
let mut read: Node = serde_json::from_value(serde_json::to_value(&n).unwrap()).unwrap();
assert!(read.extras().image_quad.is_none());
read.transform(Affine::scale_non_uniform(1.0, 4.0), false);
assert!(!read.is_distorted_image());
assert_eq!(read.geometric_bounds(), Some(Rect::new(0.0, 0.0, 100.0, 400.0)));
let mut v = serde_json::to_value(&n).unwrap();
v["image_quad"] = serde_json::json!([[0.0, 0.0], [10.0, 0.0], [10.0, 10.0]]);
let read: Node = serde_json::from_value(v).unwrap();
assert!(read.extras().image_quad.is_none());
assert!(matches!(read.kind, NodeKind::Image(_)));
// Past a fourth point the rest is skipped without being read as points.
for extra in [serde_json::json!([5.0, 5.0]), serde_json::json!("not a point")] {
let mut v = serde_json::to_value(&n).unwrap();
v["image_quad"] = serde_json::json!([[40.0, 0.0], [60.0, 0.0], [100.0, 100.0], [0.0, 100.0], extra, {"x": 1}]);
let read: Node = serde_json::from_value(v).unwrap();
assert!(read.extras().image_quad.is_none());
}
// Valid corners read back.
let q = pts([(40.0, 0.0), (60.0, 0.0), (100.0, 100.0), (0.0, 100.0)]);
n.set_image_corners(q).unwrap();
let read: Node = serde_json::from_value(serde_json::to_value(&n).unwrap()).unwrap();
assert_eq!(read.image_quad(), Some(q));
}
#[test]
fn refused_corners_change_nothing_and_a_bad_quad_in_a_file_is_ignored() {
let mut n = image(10, 10);
let before = n.clone();
assert!(n.set_image_corners(pts([(0.0, 0.0), (10.0, 0.0), (0.0, 10.0), (10.0, 10.0)])).is_err());
assert_eq!(n, before);
n.extras_mut().image_quad = Some(Box::new(pts([(0.0, 0.0), (10.0, 0.0), (0.0, 10.0), (10.0, 10.0)])));
assert_eq!(n.image_quad(), None);
assert_eq!(n.image_corners(), Some(pts([(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)])));
}
#[test]
fn the_mesh_is_as_fine_as_the_perspective_needs() {
let mut n = image(400, 400);
n.set_image_corners(pts([(10.0, 0.0), (400.0, 5.0), (390.0, 400.0), (0.0, 395.0)])).unwrap();
let NodeKind::Image(im) = n.kind.clone() else { panic!("an image") };
let gentle = cells(&n.image_map().unwrap(), &im, Density::PAGE);
n.set_image_corners(pts([(160.0, 0.0), (240.0, 0.0), (400.0, 400.0), (0.0, 400.0)])).unwrap();
let strong = cells(&n.image_map().unwrap(), &im, Density::PAGE);
assert!(gentle < strong && strong <= MAX_CELLS, "{gentle} {strong}");
// Three by two pixels drawn as large still bend, in up to MIN_CELL_CAP cells.
let mut tiny = image(3, 2);
tiny.set_image_corners(pts([(160.0, 0.0), (240.0, 0.0), (400.0, 400.0), (0.0, 400.0)])).unwrap();
let NodeKind::Image(tim) = &tiny.kind else { panic!("an image") };
assert_eq!(cells(&tiny.image_map().unwrap(), tim, Density::PAGE), MIN_CELL_CAP.min(strong));
// Drawn small, the same corners take only cells of at least 4 pixels: their longest side,
// about 431 pt, is about 17 pixels at 1/25 px a point, room for 4 cells.
let map = n.image_map().unwrap();
assert!(cells(&map, &im, Density::at_scale(1.0 / 25.0)) <= 4);
// Drawn large, a quarter of a pixel is finer than 0.05 pt, so no fewer cells than on the page.
assert!(cells(&map, &im, Density::at_scale(8.0)) >= strong);
// Each cell of the page's mesh is at least 2 pt along the longest side: about 32 pt takes
// 16 at most.
let mut small = image(400, 400);
small.set_image_corners(pts([(12.0, 0.0), (18.0, 0.0), (30.0, 30.0), (0.0, 30.0)])).unwrap();
assert!(cells(&small.image_map().unwrap(), &im, Density::PAGE) <= 16);
}
/// Each piece of the art reaches the density's overlap past its triangle, and the corners clip
/// the art, so nothing draws outside them.
#[test]
fn the_pieces_overlap_and_the_corners_clip_them() {
let mut n = image(100, 100);
let q = pts([(40.0, 0.0), (60.0, 0.0), (100.0, 100.0), (0.0, 100.0)]);
n.set_image_corners(q).unwrap();
let art = distorted_art_at(&n, Density { tolerance: 1.0, min_cell: 1.0, overlap: 3.0 }).unwrap();
let Some([edge, _]) = art.children().map(Vec::as_slice) else { panic!("an edge and a mesh") };
assert!(matches!(edge.kind, NodeKind::Path { clipping: true, .. }));
assert_eq!(edge.geometric_bounds(), Some(Rect::new(0.0, 0.0, 100.0, 100.0)));
let pieces = distorted_pieces(&art);
assert!(pieces.len() >= 2);
// The first piece's clip triangle reaches 3 pt past the image's top left corner.
let Some([clip, _]) = pieces[0].children().map(Vec::as_slice) else { panic!("a clip and an image") };
let b = clip.geometric_bounds().unwrap();
assert!(b.y0 < -2.0, "{b:?}");
}
#[test]
fn the_art_puts_the_pixel_corners_on_the_quad() {
let mut n = image(100, 100);
n.opacity = 0.5;
let q = pts([(40.0, 0.0), (60.0, 0.0), (100.0, 100.0), (0.0, 100.0)]);
n.set_image_corners(q).unwrap();
let art = distorted_art(&n).unwrap();
assert_eq!(art.opacity, 1.0);
let mut corners_seen = [false; 4];
art.walk(&mut |c| {
if let NodeKind::Image(im) = &c.kind {
for (i, (p, want)) in rect_corners(Rect::new(0.0, 0.0, 100.0, 100.0)).iter().zip(q).enumerate() {
if (im.xf * *p).distance(want) < 1e-9 {
corners_seen[i] = true;
}
}
}
});
assert_eq!(corners_seen, [true; 4]);
assert!(distorted_art(&image(4, 4)).is_none());
// A hidden image that a view draws anyway gives art that draws.
n.visible = false;
assert!(distorted_art(&n).unwrap().visible);
// The image's own fills and strokes stay off the mesh's group.
let stroke = vectorcraft_color::Paint::solid(vectorcraft_color::Color::BLACK);
n.appearance = crate::Appearance::basic(vectorcraft_color::Paint::None, stroke, 1.0).into();
assert!(distorted_art(&n).unwrap().appearance.items.is_empty());
}
#[test]
fn deep_expansion_reaches_a_distorted_image_inside_a_group() {
let mut n = image(100, 100);
n.set_image_corners(pts([(40.0, 0.0), (60.0, 0.0), (100.0, 100.0), (0.0, 100.0)])).unwrap();
let inner = Node::new(NodeId(2), NodeKind::Group { children: vec![std::sync::Arc::new(n)], clip: false });
let outer = Node::new(NodeId(3), NodeKind::Group { children: vec![std::sync::Arc::new(inner)], clip: false });
let out = crate::live::expand_deep(&outer, None);
let mut distorted = 0;
let mut pieces = 0;
out.walk(&mut |c| {
distorted += usize::from(c.is_distorted_image());
pieces += usize::from(matches!(c.kind, NodeKind::Image(_)));
});
assert_eq!(distorted, 0);
assert!(pieces > 1, "{pieces}");
}
/// A distorted image with an effect of its own stays an image with its appearance when the
/// art around it is expanded, so the effect still applies where the art is drawn.
#[test]
fn deep_expansion_keeps_a_distorted_image_with_its_own_appearance() {
let mut n = image(100, 100);
n.set_image_corners(pts([(40.0, 0.0), (60.0, 0.0), (100.0, 100.0), (0.0, 100.0)])).unwrap();
let effect = crate::Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": 40}), visible: true };
n.appearance = crate::Appearance { effects: vec![effect], ..Default::default() }.into();
let inner = Node::new(NodeId(2), NodeKind::Group { children: vec![std::sync::Arc::new(n.clone())], clip: false });
let outer = Node::new(NodeId(3), NodeKind::Group { children: vec![std::sync::Arc::new(inner)], clip: false });
let out = crate::live::expand_deep(&outer, None);
let mut kept = vec![];
out.walk(&mut |c| {
if c.is_distorted_image() {
kept.push(c.appearance.clone());
}
});
assert_eq!(kept, vec![n.appearance]);
}
}
+1
View File
@@ -22,6 +22,7 @@ pub mod graph;
mod halftone_radii;
pub mod hit;
mod id_index;
pub mod image_quad;
pub use id_index::{path_lookups, tree_walks};
pub mod inks;
mod inline;
+2 -2
View File
@@ -57,11 +57,11 @@ pub use envelope::{
envelope_content_boxes, envelope_content_boxes_with, envelope_expand, envelope_frame, envelope_grid, envelope_mapper, envelope_of,
envelope_overlay, envelope_stroke_margin, set_type_ink, smooth_handles, warp_grid,
};
pub(crate) use expand::max_outset;
pub use expand::{
Hooks, MAX_GENERATED, Outliner, PatternTiles, affine_near, expand_deep, expand_deep_hooks, expand_live, expand_live_hooks, expand_live_with,
expanded_group, expanded_group_hooks, is_live, mesh_quad_nodes, mesh_warp_cost, mesh_warp_image, subtree_has_live,
expanded_group, expanded_group_hooks, is_drawn_live, is_live, mesh_quad_nodes, mesh_warp_cost, mesh_warp_image, subtree_has_live,
};
pub(crate) use expand::{max_outset, mesh_warp_image_with};
#[cfg(test)]
use mesh::grid_eval;
pub use mesh::{Coons, GradientMesh, MeshAppearance, MeshPiece, MeshPoint, MeshQuad, default_fidelity, grid_points, nodes_bounds};
+70 -12
View File
@@ -212,12 +212,26 @@ pub fn mesh_warp_cost(cells: usize) -> usize {
/// partly transparent image keeps its own alpha there. More cells than [`MAX_GENERATED`] objects
/// allow make an empty group.
pub fn mesh_warp_image(n: &Node, im: &ImageObject, f: &dyn Fn(Point) -> Point, cells: usize, pixelated: bool, masked: bool) -> Node {
mesh_warp_image_with(n, im, f, cells, pixelated, masked, None)
}
/// [`mesh_warp_image`], each piece reaching `overlap` points past its edges when given.
pub(crate) fn mesh_warp_image_with(
n: &Node,
im: &ImageObject,
f: &dyn Fn(Point) -> Point,
cells: usize,
pixelated: bool,
masked: bool,
overlap: Option<f64>,
) -> Node {
let k = cells.max(1);
let mut g = n.clone();
g.kind = NodeKind::Group { children: vec![], clip: false };
g.knockout = crate::Knockout::On;
if let Some(e) = g.extras_if_any() {
e.colorize = None;
e.image_quad = None;
}
if mesh_warp_cost(k) > MAX_GENERATED {
return g;
@@ -228,24 +242,31 @@ pub fn mesh_warp_image(n: &Node, im: &ImageObject, f: &dyn Fn(Point) -> Point, c
let color_mask = n.extras().color_mask.clone();
let (pw, ph) = (im.width as f64, im.height as f64);
let at = |i: usize, j: usize| Point::new(pw * i as f64 / k as f64, ph * j as f64 / k as f64);
// A distorted image's pixels reach the page through its projective map.
let to_page = n.image_map().filter(|_| n.is_distorted_image());
let place = |p: Point| to_page.and_then(|m| m.apply(p)).unwrap_or(im.xf * p);
let mut pieces = Vec::with_capacity(2 * k * k);
for j in 0..k {
for i in 0..k {
let s = [at(i, j), at(i + 1, j), at(i + 1, j + 1), at(i, j + 1)];
let d = s.map(|p| f(im.xf * p));
let d = s.map(|p| f(place(p)));
for t in [[0, 1, 2], [0, 2, 3]] {
let (st, dt) = (t.map(|v| s[v]), t.map(|v| d[v]));
let Some(xf) = affine_between(st, dt) else { continue };
let c = Point::new((dt[0].x + dt[1].x + dt[2].x) / 3.0, (dt[0].y + dt[1].y + dt[2].y) / 3.0);
let grow = (dt[0].distance(dt[1]).max(dt[1].distance(dt[2])) * 0.02).min(0.5);
let tri: Vec<Point> = dt
.iter()
.map(|p| {
let v = *p - c;
let len = v.hypot();
if len > 1e-12 { *p + v * (grow / len) } else { *p }
})
.collect();
let tri: Vec<Point> = match overlap {
Some(g) => grown_triangle(dt, g),
None => {
let grow = (dt[0].distance(dt[1]).max(dt[1].distance(dt[2])) * 0.02).min(0.5);
dt.iter()
.map(|p| {
let v = *p - c;
let len = v.hypot();
if len > 1e-12 { *p + v * (grow / len) } else { *p }
})
.collect()
}
};
let shape = PathData::single(SubPath::polyline(&tri, true));
let mut image = Node::new(n.id, NodeKind::Image(Box::new(ImageObject { xf, ..im.clone() })));
image.extras_mut().pixelated = pixelated;
@@ -274,6 +295,23 @@ pub fn mesh_warp_image(n: &Node, im: &ImageObject, f: &dyn Fn(Point) -> Point, c
g
}
/// Triangle `t` with each side moved `g` outward: `t` scaled about its incenter. A corner moves
/// at most 8 `g`, so a very thin triangle's sides move less than `g`.
fn grown_triangle(t: [Point; 3], g: f64) -> Vec<Point> {
let side = |i: usize| t[(i + 1) % 3].distance(t[(i + 2) % 3]);
let (a, b, c) = (side(0), side(1), side(2));
let perimeter = a + b + c;
let area = ((t[1] - t[0]).cross(t[2] - t[0]) / 2.0).abs();
if !(perimeter > 1e-12 && area > 0.0 && g.is_finite() && g > 0.0) {
return t.to_vec();
}
let center = Point::new((a * t[0].x + b * t[1].x + c * t[2].x) / perimeter, (a * t[0].y + b * t[1].y + c * t[2].y) / perimeter);
let r = 2.0 * area / perimeter;
let far = t.iter().map(|p| p.distance(center)).fold(0.0, f64::max);
let grow = (g / r).min(8.0 * g / far.max(1e-12));
t.iter().map(|p| center + (*p - center) * (1.0 + grow)).collect()
}
/// Distort Pattern Fills: path or compound path `n` with each visible pattern fill turned into the
/// tiles it paints in a clip group shaped like `n` (with the fill's opacity and blend mode), its
/// other fills and strokes on copies of it, in paint order, under `n`'s transparency. `None`
@@ -353,6 +391,13 @@ pub fn is_live(n: &Node) -> bool {
)
}
/// Is this drawn and written as evaluated art: a live object ([`is_live`]) or a distorted image
/// ([`Node::image_quad`]), whose art is [`crate::image_quad::distorted_art`]. Effects and
/// container paint treat a distorted image as an image, not as live art.
pub fn is_drawn_live(n: &Node) -> bool {
is_live(n) || n.is_distorted_image()
}
/// Mesh tessellation as flat-filled paths (no stroke): each patch cut `n`×`n`, its quads joined
/// where the colour hardly changes ([`GradientMesh::pieces`]).
pub fn mesh_quad_nodes(m: &GradientMesh, n: usize) -> Vec<Node> {
@@ -388,6 +433,7 @@ pub fn expand_live_hooks(n: &Node, hooks: Hooks) -> Vec<Node> {
NodeKind::Repeat(r) => r.expand(hooks.symbols),
NodeKind::PlacedDocument(p) => p.art(n),
NodeKind::Intertwine { children } => crate::intertwine::expand(children),
NodeKind::Image(_) => vec![crate::image_quad::distorted_art(n).unwrap_or_else(|| n.clone())],
_ => vec![n.clone()],
}
}
@@ -429,7 +475,7 @@ pub fn expand_deep(n: &Node, outline: Outliner) -> Node {
/// expands to nothing.
pub fn expand_deep_hooks(n: &Node, hooks: Hooks) -> Node {
let _generating = Generating::enter();
let mut out = if is_live(n) {
let mut out = if is_drawn_live(n) {
let g = expanded_group_hooks(n, hooks);
if !Generating::charge(g.count()) {
return Node::new(n.id, NodeKind::Group { children: vec![], clip: false });
@@ -440,7 +486,12 @@ pub fn expand_deep_hooks(n: &Node, hooks: Hooks) -> Node {
};
if let Some(ch) = out.children_mut() {
for c in ch.iter_mut() {
if subtree_has_live(c) {
// A distorted image with fills, strokes or effects of its own stays an image: whoever
// draws the art draws it with them, as it draws a distorted image anywhere else.
if c.is_distorted_image() && !(c.appearance.items.is_empty() && c.appearance.effects.is_empty()) {
continue;
}
if subtree_has_drawn_live(c) {
*c = Arc::new(expand_deep_hooks(c, hooks));
}
}
@@ -497,6 +548,13 @@ pub fn subtree_has_live(n: &Node) -> bool {
any
}
/// Does `n` or any descendant draw as evaluated art ([`is_drawn_live`])?
fn subtree_has_drawn_live(n: &Node) -> bool {
let mut any = false;
n.walk(&mut |c| any |= is_drawn_live(c));
any
}
/// Largest stroke outset in a subtree (for visual bounds of envelopes, blends and repeats, and the
/// reach of symbol art), type's character strokes included as type's own visual bounds measure them
/// ([`crate::TextObject::char_stroke_outset`]): in an envelope they paint at their own weight
+6 -2
View File
@@ -44,8 +44,12 @@ impl Node {
}
}
NodeKind::Image(im) => {
let frame = shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf);
out.push((frame.to_bezpath(), FillRule::NonZero));
// A distorted image's frame joins its corners.
let frame = match self.image_frame().filter(|_| self.is_distorted_image()) {
Some(bp) => bp,
None => shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf).to_bezpath(),
};
out.push((frame, FillRule::NonZero));
}
NodeKind::PlacedDocument(p) => {
let frame = shapes::rectangle(p.natural()).transformed(p.xf);
+6
View File
@@ -3,6 +3,7 @@ use super::kind::NodeKind;
use super::live_shape::LiveShape;
use super::opacity::OpacityMask;
use super::{Node, PathData};
use vectorcraft_geom::Point;
/// The parts of a [`Node`] that few objects have: kept out of line, so that the nodes without
/// them stay small ([`Node::extras`]).
@@ -87,6 +88,10 @@ pub struct NodeExtras {
/// are applied, one path or compound path per fill and stroke: as the clipping path of a clip group it paints
/// those pieces as the path paints its fills and strokes ([`Node::clip_paint`]).
pub clip_pieces: bool,
/// As an image after Perspective Distort or Free Distort, where its pixel rectangle's corners
/// (top left, top right, bottom right, bottom left in pixel space) stand on the page when they
/// do not make a parallelogram, which its transform alone could place ([`crate::image_quad`]).
pub image_quad: Option<Box<[Point; 4]>>,
}
/// No extras: what [`Node::extras`] gives for a node without any.
@@ -118,6 +123,7 @@ pub(super) static NO_EXTRAS: NodeExtras = NodeExtras {
color_mask: None,
warp_piece: false,
clip_pieces: false,
image_quad: None,
};
/// A node's [`NodeExtras`], if it has any ([`Node::extras`]). Extras that are all unset equal
+26 -1
View File
@@ -386,6 +386,10 @@ impl Node {
.filter(|c| c.visible || !matches!(self.kind, NodeKind::Layer { .. }))
.fold(None, |acc, c| vectorcraft_geom::union_opt(acc, c.geometric(symbols))),
NodeKind::Text(t) => self.projected(t.bounds()),
// A distorted image is bounded by its corners.
NodeKind::Image(_) if self.is_distorted_image() => {
self.image_corners().map(|q| q[1..].iter().fold(Rect::from_points(q[0], q[0]), |r, p| r.union_pt(*p)))
}
NodeKind::Image(im) => Some(im.xf.transform_rect_bbox(Rect::new(0.0, 0.0, im.width as f64, im.height as f64))),
NodeKind::SymbolInstance { symbol, xf } => {
let art = symbols.and_then(|s| s.art(symbol)).map_or(SYMBOL_SQUARE, |a| a.geometric);
@@ -528,6 +532,9 @@ impl Node {
}
// The path the objects are attached to, before it is transformed.
let on_path_before = self.on_path_data().cloned();
// A distorted image's placement nearest its corners, before they are transformed (`None`
// within when its stored corners are refused, and `None` for anything else).
let image_before = self.extras().image_quad.is_some().then(|| crate::image_quad::nearest_affine(self));
if !self.is_layer() {
self.bbox_angle = crate::orient::transformed_angle(self.bbox_angle, a);
}
@@ -637,7 +644,8 @@ impl Node {
{
Arc::make_mut(&mut m.art).transform_scaled(a, sc);
}
// The area where an Intertwine member is drawn over the others moves with it.
// The area where an Intertwine member is drawn over the others moves with it, and so do a
// distorted image's corners.
if let Some(e) = self.extras_if_any() {
if let Some(area) = e.intertwine.as_mut() {
area.transform(a);
@@ -645,6 +653,23 @@ impl Node {
for area in &mut e.intertwine_tiers {
area.transform(a);
}
if let Some(q) = e.image_quad.as_mut() {
for p in q.iter_mut() {
*p = a * *p;
}
}
}
// Corners that a scale squeezes past what a perspective map can place (or that were
// refused already) leave the image placed by its transform: for valid corners, the
// placement that was nearest them, transformed, rather than the rectangle it had before
// it was distorted.
if let Some(before) = image_before
&& self.image_quad().is_none()
{
if let (Some(near), NodeKind::Image(im)) = (before, &mut self.kind) {
im.xf = a * near;
}
self.extras_mut().image_quad = None;
}
}
+48
View File
@@ -59,6 +59,7 @@ impl Serialize for Node {
e.color_mask.is_none(),
is_default(&e.warp_piece),
is_default(&e.clip_pieces),
e.image_quad.is_none(),
];
let mut st = s.serialize_struct("Node", skips.iter().filter(|s| !**s).count())?;
let mut skip = skips.into_iter();
@@ -106,6 +107,7 @@ impl Serialize for Node {
field!("color_mask", &e.color_mask);
field!("warp_piece", &e.warp_piece);
field!("clip_pieces", &e.clip_pieces);
field!("image_quad", &e.image_quad);
st.end()
}
}
@@ -257,10 +259,55 @@ pub(super) struct NodeWire {
warp_piece: bool,
#[serde(default)]
clip_pieces: bool,
#[serde(default, deserialize_with = "image_corners")]
image_quad: Option<Box<[vectorcraft_geom::Point; 4]>>,
}
/// A distorted image's corners as a file holds them: a list of exactly four points, else none (the
/// image is then placed by its transform). At most five points of a longer list are kept while it
/// is read.
fn image_corners<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Option<Box<[vectorcraft_geom::Point; 4]>>, D::Error> {
use vectorcraft_geom::Point;
struct Corners;
impl<'de> serde::de::Visitor<'de> for Corners {
type Value = Option<Box<[Point; 4]>>;
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.write_str("a list of points")
}
fn visit_none<E: serde::de::Error>(self) -> Result<Self::Value, E> {
Ok(None)
}
fn visit_unit<E: serde::de::Error>(self) -> Result<Self::Value, E> {
Ok(None)
}
fn visit_some<D: serde::Deserializer<'de>>(self, d: D) -> Result<Self::Value, D::Error> {
d.deserialize_seq(Corners)
}
fn visit_seq<A: serde::de::SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
let mut points = Vec::with_capacity(4);
while points.len() < 4
&& let Some(p) = seq.next_element::<Point>()?
{
points.push(p);
}
// A fifth entry drops the field, so the rest is skipped without decoding it.
let mut extra = false;
while seq.next_element::<serde::de::IgnoredAny>()?.is_some() {
extra = true;
}
Ok(if extra { None } else { <[Point; 4]>::try_from(points).ok().map(Box::new) })
}
}
d.deserialize_option(Corners)
}
impl From<NodeWire> for Node {
fn from(w: NodeWire) -> Self {
// Corners an image cannot take are dropped, so a later transform cannot make them its own.
let image_quad = match &w.kind {
NodeKind::Image(im) => w.image_quad.filter(|q| crate::image_quad::check_for(im, q).is_ok()),
_ => None,
};
let extras = NodeExtras {
mask: w.mask,
trace: w.trace,
@@ -289,6 +336,7 @@ impl From<NodeWire> for Node {
color_mask: w.color_mask,
warp_piece: w.warp_piece,
clip_pieces: w.clip_pieces,
image_quad,
};
Node {
id: w.id,
+37
View File
@@ -686,6 +686,43 @@ fn reid_gives_fresh_ids() {
assert!(!ids.contains(&a) && !ids.contains(&b));
}
/// A copy of a node in the document takes the Symbol Set Density recorded for it; a node from
/// another document with the same id does not.
#[test]
fn reid_copies_the_set_density_of_the_documents_own_node() {
let (mut d, a, _) = doc_with_rects();
d.unknown.insert(Document::SYMBOL_SET_DENSITY_KEY.into(), serde_json::json!({ a.0.to_string(): 2.0 }));
let density = |d: &Document, id: NodeId| d.unknown[Document::SYMBOL_SET_DENSITY_KEY].get(id.0.to_string()).cloned();
let own = d.node(a).cloned().unwrap();
let copy = d.reid(&own);
assert_eq!(density(&d, copy.id), Some(serde_json::json!(2.0)));
let foreign = Node::group(a, vec![]);
let copy = d.reid(&foreign);
assert_eq!(density(&d, copy.id), None);
}
/// A pasted copy and its descendants take the densities recorded at Copy, and none where Copy
/// recorded none, whatever [`Document::reid`] found for an identical node in the document.
#[test]
fn carry_set_densities_gives_the_densities_recorded_at_copy() {
let (mut d, a, b) = doc_with_rects();
d.unknown.insert(Document::SYMBOL_SET_DENSITY_KEY.into(), serde_json::json!({ a.0.to_string(): 2.0 }));
let density = |d: &Document, id: NodeId| d.unknown[Document::SYMBOL_SET_DENSITY_KEY].get(id.0.to_string()).cloned();
let (na, nb) = (d.node(a).cloned().unwrap(), d.node(b).cloned().unwrap());
// Copy recorded nothing for `a`: the copy reid gave a density loses it.
let copy = d.reid(&na);
assert_eq!(density(&d, copy.id), Some(serde_json::json!(2.0)));
d.carry_set_densities(&na, &copy, &Default::default());
assert_eq!(density(&d, copy.id), None);
// Copy recorded 7 for `b` inside a group: the group's copy has none, and `b`'s copy has 7.
let g = d.alloc_id();
let group = Node::group(g, vec![Arc::new(nb)]);
let copy = d.reid(&group);
d.carry_set_densities(&group, &copy, &[(b, serde_json::json!(7.0))].into_iter().collect());
let inner = copy.children().unwrap()[0].id;
assert_eq!((density(&d, copy.id), density(&d, inner)), (None, Some(serde_json::json!(7.0))));
}
#[test]
fn setup_round_trips_and_old_files_load() {
let (mut d, _, _) = doc_with_rects();
+13
View File
@@ -451,12 +451,25 @@ impl TextObject {
/// fractions of the path. False, changing nothing, for other type, when the anchor doesn't
/// exist, a degenerate `xf` or a path that would not be finite.
pub fn set_path_handle(&mut self, (si, ai): (usize, usize), out: bool, pos: Point, independent: bool) -> bool {
self.set_path_handle_with_symmetry((si, ai), out, pos, independent, false)
}
/// [`Self::set_path_handle`] with an optional mirror of the opposite handle about the anchor
/// in document space, preserving the anchor kind. `independent` takes precedence, and at an
/// open end of the path, where no segment leaves the anchor on that side, the handle moves as
/// it would without `symmetric`. Both handles are edited in one reshape, using the same validated
/// document-to-text map.
pub fn set_path_handle_with_symmetry(&mut self, (si, ai): (usize, usize), out: bool, pos: Point, independent: bool, symmetric: bool) -> bool {
let xf = self.xf;
matches!(self.kind, TextKind::OnPath { .. })
&& self.reshape_local(|path, to_text| {
let mirror = symmetric && !independent && path.subpaths.get(si).is_some_and(|sp| sp.has_segment(ai, !out));
let Some(a) = path.anchor_mut(si, ai) else { return false };
let mut drawn = a.transform(xf);
drawn.set_handle(out, pos, independent);
if mirror {
let opposite = drawn.p - (pos - drawn.p);
if out { drawn.h_in = opposite } else { drawn.h_out = opposite }
}
*a = drawn.transform(to_text);
true
})
+6 -8
View File
@@ -111,6 +111,8 @@ fn lengths_of(id: &str) -> Lengths {
"sketch.tornEdges" => always(&["smoothness"]),
"sketch.waterPaper" => always(&["fiberLength"]),
TRAP => always(&["thickness", "precision"]),
// The Pathfinder Options' refit tolerance.
id if crate::takes_pathfinder_options(id) => always(&["precision"]),
RASTERIZE => always(&["addAround"]),
// The points one unit of the filter measures.
crate::SVG_FILTER => always(&["scale"]),
@@ -832,15 +834,11 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
}
for (id, label, _) in PATHFINDER_EFFECTS {
if id == "pathfinder.softMix" {
v.push(g(
id,
label,
PATHFINDER,
"{mixingRate?: 1..100 % (50)} blend overlapping fills in CMYK bottom to top (groups and layers: live Pathfinder over the members)",
json!({"mixingRate": 50.0}),
));
v.push(g(id, label, PATHFINDER, crate::group::SOFT_MIX_PARAMS_DOC, json!({"mixingRate": 50.0})));
} else {
v.push(g(id, label, PATHFINDER, "{} (groups and layers: live Pathfinder over the members)", json!({})));
// No dialog defaults, so the Effect menu applies it directly; effect.apply fills its
// Pathfinder Options in.
v.push(g(id, label, PATHFINDER, crate::group::PATHFINDER_PARAMS_DOC, json!({})));
}
}
v.extend(crate::addons::color::catalog());
+121 -8
View File
@@ -51,6 +51,80 @@ fn op_of(id: &str) -> Option<PathfinderOp> {
PATHFINDER_EFFECTS.iter().find(|e| e.0 == id).map(|e| e.2)
}
/// Does effect `id` keep Pathfinder Options of its own ([`PathfinderEffectOptions`]): one of
/// [`PATHFINDER_EFFECTS`] (Trap has options of its own)?
pub fn takes_pathfinder_options(id: &str) -> bool {
op_of(id).is_some()
}
/// The parameters holding a Pathfinder effect's Pathfinder Options.
pub const PATHFINDER_OPTION_KEYS: [&str; 3] = ["precision", "removeRedundantPoints", "removeUnpainted"];
/// The range of a Pathfinder effect's `precision` (pt), the Pathfinder panel's range.
pub const PATHFINDER_EFFECT_PRECISION: std::ops::RangeInclusive<f64> = 0.001..=10.0;
/// The documentation of [`PATHFINDER_OPTION_KEYS`], as a literal for `concat!`.
macro_rules! options_doc {
() => {
"precision?: pt 0.001..10 (effect.apply: Pathfinder Options › Precision; 0.01 when missing; results are refit to within it and pieces thinner than it are dropped), removeRedundantPoints?: bool (effect.apply: Pathfinder Options › Remove Redundant Points; false when missing; results lose the anchors that don't change their shape to within precision), removeUnpainted?: bool (effect.apply: Pathfinder Options › Divide and Outline Will Remove Unpainted Artwork; false when missing; Divide and Outline leave out the pieces of members with no visible fill, a compound shape's area going by the shape's own fill, except that Divide keeps every piece when the group or compound shape has a visible fill of its own; the other operations ignore it)"
};
}
/// The documentation of [`PATHFINDER_OPTION_KEYS`], shared by the Pathfinder effects' parameters.
pub const PATHFINDER_OPTIONS_DOC: &str = options_doc!();
/// The parameters of a Pathfinder effect other than Soft Mix.
pub const PATHFINDER_PARAMS_DOC: &str = concat!("{", options_doc!(), "} (groups and layers: live Pathfinder over the members)");
/// The parameters of Effect › Pathfinder › Soft Mix.
pub const SOFT_MIX_PARAMS_DOC: &str = concat!(
"{mixingRate?: 1..100 % (50), ",
options_doc!(),
"} blend overlapping fills in CMYK bottom to top (groups and layers: live Pathfinder over the members)"
);
/// The Pathfinder Options a Pathfinder effect evaluates with, read from its parameters. An effect
/// without them (saved before effects kept their own) evaluates as it did then: the default
/// precision, with no points or pieces removed.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PathfinderEffectOptions {
/// Refit tolerance of the results, in points ([`PATHFINDER_EFFECT_PRECISION`]).
pub precision: f64,
/// Drop anchors that don't change a result's shape.
pub remove_redundant_points: bool,
/// Divide and Outline leave out the pieces of members with no visible fill.
pub remove_unpainted: bool,
}
impl Default for PathfinderEffectOptions {
fn default() -> Self {
PathfinderEffectOptions { precision: po::DEFAULT_PRECISION, remove_redundant_points: false, remove_unpainted: false }
}
}
impl PathfinderEffectOptions {
/// The options in `p`: a missing or non-numeric value takes its default and a precision out of
/// range its nearest bound, so a live effect always evaluates.
pub fn from_params(p: &Value) -> Self {
let d = PathfinderEffectOptions::default();
let (lo, hi) = (*PATHFINDER_EFFECT_PRECISION.start(), *PATHFINDER_EFFECT_PRECISION.end());
PathfinderEffectOptions {
precision: crate::util::num(p, "precision", d.precision).clamp(lo, hi),
remove_redundant_points: crate::util::flag(p, "removeRedundantPoints", d.remove_redundant_points),
remove_unpainted: crate::util::flag(p, "removeUnpainted", d.remove_unpainted),
}
}
/// These options as the parameters [`PATHFINDER_OPTION_KEYS`] name.
pub fn to_params(self) -> Value {
serde_json::json!({
"precision": self.precision,
"removeRedundantPoints": self.remove_redundant_points,
"removeUnpainted": self.remove_unpainted,
})
}
}
/// Does `n` (a group or layer) carry a visible Pathfinder effect, or is it a compound shape?
pub fn has_pathfinder(n: &Node) -> bool {
n.is_compound_shape()
@@ -503,6 +577,23 @@ pub fn pathfinder_children(doc: Option<&Document>, group: &Node, hook: Option<Ou
out.extend(source.iter().skip(art).cloned());
return Some(out);
}
// When the group has a visible fill of its own, that fill paints its members' geometry, a
// compound shape's area included ([`evaluate_container`]), so Remove Unpainted Artwork keeps
// every Divide piece. Outline's open segments still go by their source's fill.
let own_fill = has_visible_fill(group);
// A compound shape's area has no paint of its own: the shape's own appearance paints it. The
// shape's top painting fill is the area's fill for Remove Unpainted Artwork and for Outline's
// strokes, while Divide pieces stay unpainted so that the fill is not drawn twice.
let area_style = group.is_compound_shape().then(|| {
let items = group.appearance.items.iter().filter(|i| paints(i)).cloned().collect();
Node::path(group.id, PathData::default(), Appearance { items, ..Default::default() })
});
let style_of = |s: &Node| -> Option<Node> {
let a = area_style.as_ref().filter(|_| s.id == group.id && s.appearance.items.is_empty())?;
let mut a = a.clone();
(a.opacity, a.blend) = (s.opacity, s.blend);
Some(a)
};
let mut stack: Vec<Arc<Node>> = if group.is_compound_shape() {
// The group's own appearance paints the area ([`evaluate_container`]), so the art has none.
match compound_shape_area(doc, group, hook) {
@@ -535,6 +626,7 @@ pub fn pathfinder_children(doc: Option<&Document>, group: &Node, hook: Option<Ou
continue;
}
let Some(op) = op_of(&e.id) else { continue };
let options = PathfinderEffectOptions::from_params(&e.params);
let shape_mode =
matches!(op, PathfinderOp::Unite | PathfinderOp::MinusFront | PathfinderOp::Intersect | PathfinderOp::Exclude | PathfinderOp::MinusBack);
let nodes = SymbolNodes::default();
@@ -558,7 +650,7 @@ pub fn pathfinder_children(doc: Option<&Document>, group: &Node, hook: Option<Ou
let refs: Vec<(&PathData, FillRule)> = parts.iter().map(|(p, r)| (p, *r)).collect();
let key = sources.len() as u64;
if let Some(top) = lv.pop() {
shapes.push(po::Shape::new(po::unite_all(&refs), FillRule::NonZero, key));
shapes.push(po::Shape::new(po::unite_all_with(&refs, options.precision), FillRule::NonZero, key));
sources.push(top);
}
} else {
@@ -574,24 +666,40 @@ pub fn pathfinder_children(doc: Option<&Document>, group: &Node, hook: Option<Ou
if shapes.is_empty() {
return Some(vec![]);
}
// Remove Redundant Points: each result loses the anchors that don't change its shape.
let tidy = |path: PathData| if options.remove_redundant_points { po::remove_redundant_points(&path, options.precision) } else { path };
stack = if op == PathfinderOp::SoftMix {
let rate = mixing_rate(&e.params);
po::regions(&shapes)
po::regions_with(&shapes, options.precision)
.into_iter()
.filter(|r| !r.path.is_empty())
.map(|r| Arc::new(soft_mix_face(r.path, &r.sources, rate, &shapes, &sources)))
.map(|r| Arc::new(soft_mix_face(tidy(r.path), &r.sources, rate, &shapes, &sources)))
.collect()
} else if op == PathfinderOp::HardMix {
po::regions(&shapes)
po::regions_with(&shapes, options.precision)
.into_iter()
.filter(|r| !r.path.is_empty())
.map(|r| Arc::new(hard_mix_face(r.path, &r.sources, &shapes, &sources)))
.map(|r| Arc::new(hard_mix_face(tidy(r.path), &r.sources, &shapes, &sources)))
.collect()
} else {
po::pathfinder(op, &shapes)
// Divide and Outline Will Remove Unpainted Artwork: the pieces of members with no
// visible fill go.
let unpainted = options.remove_unpainted
&& match op {
PathfinderOp::Divide => !own_fill,
PathfinderOp::Outline => true,
_ => false,
};
let fill_sources: Vec<Option<Node>> = sources.iter().map(style_of).collect();
let fill_source = |k: u64| fill_sources[k as usize].as_ref().unwrap_or(&sources[k as usize]);
po::pathfinder_with(op, &shapes, options.precision)
.into_iter()
.filter(|r| !r.path.is_empty())
.map(|r| Arc::new(styled(&sources[r.key as usize], r.path, op == PathfinderOp::Outline)))
.filter(|r| !r.path.is_empty() && !(unpainted && !has_visible_fill(fill_source(r.key))))
.map(|r| {
let outline = op == PathfinderOp::Outline;
let src = if outline { fill_source(r.key) } else { &sources[r.key as usize] };
Arc::new(styled(src, tidy(r.path), outline))
})
.collect()
};
}
@@ -676,6 +784,11 @@ pub fn paints(item: &AppearanceItem) -> bool {
}
}
/// Has `n` a visible fill that paints, as the Pathfinder panel's Remove Unpainted Artwork counts it?
fn has_visible_fill(n: &Node) -> bool {
n.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Fill(f) if f.visible && !f.paint.is_none()))
}
/// Do the own fills or strokes of `n`, a group or layer, paint anything?
pub(crate) fn has_own_paint(n: &Node) -> bool {
is_container(n) && n.appearance.items.iter().any(paints)
+75
View File
@@ -213,6 +213,81 @@ fn divide_and_outline_draw_nothing_for_unpainted_members() {
}
}
/// With Remove Unpainted Artwork, Divide and Outline keep the area of a compound shape whose own
/// appearance has a visible fill and leave out the area of one without.
#[test]
fn remove_unpainted_keeps_a_filled_compound_shapes_area() {
for effect in ["pathfinder.divide", "pathfinder.outline"] {
for filled in [true, false] {
let mut g = compound_shape(ShapeMode::Add);
if !filled {
g.appearance = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 1.0).into();
}
g.appearance.effects.push(Effect { id: effect.into(), params: serde_json::json!({"removeUnpainted": true}), visible: true });
let out = pathfinder_children(None, &g, None).unwrap();
assert_eq!(!out.is_empty(), filled, "{effect}, filled {filled}: {out:#?}");
}
}
}
/// Outline strokes a compound shape's area in the shape's own fill (its top visible one that
/// paints), with Remove Unpainted Artwork on or off, and Divide leaves the area's pieces
/// unpainted for the shape's fill to paint.
#[test]
fn outline_strokes_a_compound_shapes_area_in_its_fill() {
let green = Paint::solid(Color::rgb(0.0, 1.0, 0.0));
for (remove, covered) in [(false, false), (true, false), (false, true), (true, true)] {
for effect in ["pathfinder.divide", "pathfinder.outline"] {
let mut g = compound_shape(ShapeMode::Add);
if covered {
// A hidden fill and an unpainted fill above the green one.
let mut hidden = FillLayer::new(Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
hidden.visible = false;
let mut a = (*g.appearance).clone();
a.insert_item(a.items.len(), AppearanceItem::Fill(hidden));
a.insert_item(a.items.len(), AppearanceItem::Fill(FillLayer::new(Paint::None)));
g.appearance = a.into();
}
g.appearance.effects.push(Effect { id: effect.into(), params: serde_json::json!({"removeUnpainted": remove}), visible: true });
let out = pathfinder_children(None, &g, None).unwrap();
assert!(!out.is_empty(), "{effect}, remove {remove}");
for n in &out {
if effect == "pathfinder.outline" {
assert_eq!(n.appearance.stroke_paint(), green, "{effect}, remove {remove}: {n:#?}");
assert!(n.appearance.fill_paint().is_none(), "{effect}, remove {remove}: {n:#?}");
} else {
assert!(n.appearance.items.is_empty(), "{effect}, remove {remove}: {n:#?}");
}
}
}
}
}
/// With Remove Unpainted Artwork, Divide keeps the pieces of an unfilled member when its group's
/// own visible fill paints them and leaves them out when the group has no fill. Outline leaves out
/// the member's segments either way.
#[test]
fn remove_unpainted_keeps_members_a_groups_own_fill_paints() {
let unfilled = Arc::new(Node::path(
NodeId(2),
shapes::rectangle(Rect::new(5.0, 0.0, 15.0, 10.0)),
Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 1.0),
));
for effect in ["pathfinder.divide", "pathfinder.outline"] {
for filled in [true, false] {
let mut g = Node::group(NodeId(10), vec![sq(1, 0.0, Color::rgb(1.0, 0.0, 0.0)), unfilled.clone()]);
if filled {
g.appearance = Appearance::basic(Paint::solid(Color::rgb(0.0, 1.0, 0.0)), Paint::None, 0.0).into();
}
g.appearance.effects.push(Effect { id: effect.into(), params: serde_json::json!({"removeUnpainted": true}), visible: true });
let out = pathfinder_children(None, &g, None).unwrap();
assert!(out.iter().any(|n| n.id == NodeId(1)), "{effect}, filled {filled}: {out:#?}");
let kept = filled && effect == "pathfinder.divide";
assert_eq!(out.iter().any(|n| n.id == NodeId(2)), kept, "{effect}, filled {filled}: {out:#?}");
}
}
}
/// Returns an "H" in blue type at 100 pt on a baseline at y = 80, with its stems on either
/// side of x = 100.
fn type_h() -> Node {
+3 -2
View File
@@ -75,8 +75,9 @@ pub use bake::{
};
pub use clip::{WarpSeams, clip_outline, knockout_silhouette, reshaped_clip_outline, warp_pieces_translucent};
pub use group::{
OutlineHook, PATHFINDER_EFFECTS, compound_shape_area, compound_shape_art, evaluate_container, has_container_appearance, has_pathfinder,
is_pathfinder, member_leaves, member_shapes, paints, pathfinder_children, pinned_container_appearance, shape_art,
OutlineHook, PATHFINDER_EFFECT_PRECISION, PATHFINDER_EFFECTS, PATHFINDER_OPTION_KEYS, PATHFINDER_OPTIONS_DOC, PathfinderEffectOptions,
compound_shape_area, compound_shape_art, evaluate_container, has_container_appearance, has_pathfinder, is_pathfinder, member_leaves,
member_shapes, paints, pathfinder_children, pinned_container_appearance, shape_art, takes_pathfinder_options,
};
pub use lighting_presets::{LIGHTING_PRESETS, LightingPreset, lighting_preset_params, matching_lighting_preset};
pub use live::{expand_live, expand_live_deep, expanded_live_group, outline_object, text_outliner};
+7 -2
View File
@@ -120,7 +120,10 @@ pub fn new_effect(id: &str, params: &Value) -> Option<Effect> {
/// Scale the distance parameters of `e` by `s` (Scale Strokes & Effects; see
/// [`EffectInfo::lengths`]), and its sizes in raster pixels ([`crate::raster_px_range`]), which
/// keep their share of the object so. A distance left at its default is written out scaled; one
/// the effect doesn't have (Outline Stroke's weight following its stroke) stays absent.
/// the effect doesn't have (Outline Stroke's weight following its stroke) stays absent. A Pathfinder
/// effect without a `precision` gets the precision it evaluates with, scaled. Values are scaled
/// as stored, out of range or not, so a scale and its inverse restore them; evaluation applies
/// each effect's range.
pub fn scale_effect(e: &mut Effect, s: f64) {
let Some(info) = catalog_index().get(e.id.as_str()) else { return };
let merged = merged_params(&e.id, &e.params);
@@ -128,7 +131,9 @@ pub fn scale_effect(e: &mut Effect, s: f64) {
let mut keys: Vec<&str> = info.lengths.keys(relative).collect();
keys.extend(merged.as_object().into_iter().flat_map(|m| m.keys()).map(String::as_str).filter(|k| crate::raster_px_range(&e.id, k).is_some()));
for k in keys {
let v = util::num(&merged, k, f64::NAN);
let missing =
if k == "precision" && crate::takes_pathfinder_options(&e.id) { crate::PathfinderEffectOptions::default().precision } else { f64::NAN };
let v = util::num(&merged, k, missing);
if v.is_finite() {
if !e.params.is_object() {
e.params = Value::Object(Map::new());
+39 -4
View File
@@ -1248,15 +1248,20 @@ fn as_art_opts(
let fx = geometry_effects(n);
let mut art = match &n.kind {
NodeKind::Image(im) => {
let frame = shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf);
// A distorted image's frame joins its corners.
let frame = match n.image_frame().filter(|_| n.is_distorted_image()) {
Some(bp) => PathData::from_bezpath(&bp),
None => shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf),
};
let mut image = Node::new(n.id, n.kind.clone());
// Its pixels draw as the image's do: colorized by a grayscale image's fill color,
// smoothed or not, and with its color mask's masked pixels.
// smoothed or not, with its color mask's masked pixels, and distorted.
{
let mut e = image.extras_mut();
e.colorize = n.extras().colorize.clone();
e.pixelated = n.extras().pixelated;
e.color_mask = n.extras().color_mask.clone();
e.image_quad = n.extras().image_quad.clone();
}
let clipped = || {
let mut clip = Node::path(n.id, frame.clone(), Appearance::default());
@@ -1276,6 +1281,17 @@ fn as_art_opts(
clipped()
} else {
let opaque = std::cell::OnceCell::new();
// A distorted image's opaque area, traced in its pixels, goes to the page through
// its projective map.
let opaque_on_page = || match n.image_map().filter(|_| n.is_distorted_image()) {
Some(map) => {
let plain = ImageObject { xf: Affine::IDENTITY, ..(**im).clone() };
let piece = f64::from(im.width.max(im.height).max(1)) / 64.0;
opaque_area(&[symbols, paint_doc], &plain)
.map(|p| vectorcraft_doc::live::map_nonlinear(&p, piece, |q| map.apply(q).unwrap_or(q)))
}
None => opaque_area(&[symbols, paint_doc], im),
};
let rows = |items: Vec<AppearanceItem>| {
let mut out = vec![];
let mut items = items.into_iter().peekable();
@@ -1285,7 +1301,7 @@ fn as_art_opts(
while let Some(next) = items.next_if(|i| follows_opaque_area(i) == follows) {
run.push(next);
}
let path = if follows { opaque.get_or_init(|| opaque_area(&[symbols, paint_doc], im)).as_ref() } else { None };
let path = if follows { opaque.get_or_init(opaque_on_page).as_ref() } else { None };
let path = path.unwrap_or(&frame);
if !path.is_empty() {
out.push(Arc::new(Node::path(n.id, path.clone(), Appearance { items: run, ..Default::default() })));
@@ -3718,8 +3734,21 @@ fn restore_warped_images(n: &mut Node, warped: &WarpedImages, cut: bool) {
// The pieces start from the image as it was placed when it took its first warp.
let first = warps.first().map(|(_, at)| ImageObject { xf: *at, ..(**own).clone() });
let map = warped_map(warps, own.xf);
// A placement with no inverse cannot take a distorted image's corners back.
let det = own.xf.determinant();
let back = warps.first().filter(|_| det.is_finite() && det != 0.0).map(|(_, at)| *at * own.xf.inverse()).filter(Affine::is_finite);
let distorted = image.extras().image_quad.is_some();
*c = Arc::new(match (first, map) {
(Some(first), Some(map)) if cut => {
(Some(first), Some(map)) if cut && (back.is_some() || !distorted) => {
// A distorted image's corners go back to where they stood at its first warp, as
// its placement does: the moves since then are in `map`.
if let Some(back) = back
&& let Some(q) = image.extras_if_any().and_then(|e| e.image_quad.as_mut())
{
for p in q.iter_mut() {
*p = back * *p;
}
}
let pixelated = image.extras().pixelated;
vectorcraft_doc::live::mesh_warp_image(&image, &first, &*map, WARP_IMAGE_CELLS, pixelated, false)
}
@@ -3787,6 +3816,12 @@ fn copy_placed(n: &mut Node, m: Affine, copies: usize, scaling: vectorcraft_doc:
NodeKind::SymbolInstance { xf: at, .. } => *at = xf * *at,
_ => {}
}
// A distorted image's corners move with it.
if let Some(q) = one.extras_if_any().and_then(|e| e.image_quad.as_mut()) {
for p in q.iter_mut() {
*p = xf * *p;
}
}
// The placed gradients of its own fills and strokes move with it, as a path's do.
if xf != Affine::IDENTITY && one.appearance.has_positioned_gradient() {
one.appearance.transform_gradients(xf);
+6 -7
View File
@@ -8,7 +8,7 @@ use std::borrow::Cow;
use std::sync::Arc;
use vectorcraft_doc::{Appearance, AppearanceItem, Document, FillLayer, Node, NodeKind};
use vectorcraft_geom::{FillRule, PathData, Point, Rect, SubPath};
use vectorcraft_geom::{FillRule, PathData, Rect, SubPath};
use vectorcraft_pathops as po;
use super::{MAX_MEMBERS, Scope, geometry, is_container, members, profile, region, reshape_members, solid_paints};
@@ -144,18 +144,17 @@ impl Resolver<'_> {
}
/// Does the plain image `c` lie wholly outside what the clips around it show together, each
/// clipping path with its own fill rule? Its frame, the pixel rectangle as its transform places
/// it, is cut to each clip in turn until nothing is left. An error when a cut fails or the cuts
/// pass [`MAX_IMAGE_CUTS`]: the image may show, so it can't be left out.
/// clipping path with its own fill rule? Its frame, the quadrilateral of its corners
/// ([`Node::image_corners`]: a distorted image's corners, else the pixel rectangle as its
/// transform places it), is cut to each clip in turn until nothing is left. An error when a
/// cut fails or the cuts pass [`MAX_IMAGE_CUTS`]: the image may show, so it can't be left out.
fn hidden(&mut self, c: &Node) -> Result<bool, String> {
let Some(shown) = &self.shown else { return Ok(false) };
let NodeKind::Image(im) = &c.kind else { return Ok(false) };
let Some(corners) = c.image_corners() else { return Ok(false) };
let Some(b) = c.visual_bounds() else { return Ok(true) };
if b.intersect(shown.bounds).area() <= 0.0 {
return Ok(true);
}
let (w, h) = (f64::from(im.width), f64::from(im.height));
let corners = [(0.0, 0.0), (w, 0.0), (w, h), (0.0, h)].map(|(x, y)| im.xf * Point::new(x, y));
if corners.iter().any(|p| !p.x.is_finite() || !p.y.is_finite()) {
return Err(image_refusal(self.label));
}
+56
View File
@@ -504,6 +504,38 @@ fn warped_images_keep_document_keys_and_hidden_images_apart() {
}
}
/// A distorted image that a later effect leaves with no area after its warp is not cut, and its
/// corners stay finite.
#[test]
fn a_distorted_image_left_with_no_area_after_its_warp_keeps_finite_corners() {
use std::rc::Rc;
use std::sync::Arc;
use vectorcraft_doc::NodeId;
let lift: crate::reshape::WarpMap = Rc::new(|p: Point| Point::new(p.x, p.y - p.x * 0.1));
let mut image = (*warp_test_image(2)).clone();
image.set_image_corners([(10.0, 0.0), (30.0, 0.0), (40.0, 40.0), (0.0, 40.0)].map(|(x, y)| Point::new(x, y))).unwrap();
let mut art = Node::group(NodeId(1), vec![Arc::new(image)]);
let mut warped = crate::reshape::WarpedImages::new();
warped.reserve(&art);
crate::reshape::mark_warped_images(&mut art, &lift, &std::collections::HashSet::new(), false, &mut 0, &mut warped);
// A later effect squeezes the placement flat.
if let Some(c) = art.children_mut()
&& let NodeKind::Image(im) = &mut Arc::make_mut(&mut c[0]).kind
{
im.xf = Affine::scale_non_uniform(1.0, 0.0);
}
crate::reshape::cut_warped_images_within(&mut art, &warped, usize::MAX);
let mut finite = true;
art.walk(&mut |c| {
if let Some(q) = c.extras().image_quad.as_deref() {
finite &= q.iter().all(|p| p.x.is_finite() && p.y.is_finite());
}
});
assert!(finite);
assert_eq!(warp_test_images(&art).0, 1, "not cut");
}
/// An image whose frame keeps its shape because the warp would pass the anchor budget keeps its
/// pixels as they are; within the budget, both bend.
#[test]
@@ -2121,3 +2153,27 @@ fn color_halftones_radius_is_in_raster_pixels_not_a_distance() {
crate::scale_effect(&mut e, 2.0);
assert_eq!((e.params["maxRadius"].as_f64(), e.params["channel1"].as_f64()), (Some(20.0), Some(108.0)));
}
#[test]
fn a_pathfinder_effects_precision_is_a_distance_that_scales_with_the_object() {
for (id, _, _) in PATHFINDER_EFFECTS {
assert!(is_length(id, "precision", false), "{id}");
assert_eq!(length_range(id, "precision"), Some(PATHFINDER_EFFECT_PRECISION), "{id}");
assert!(!is_length(id, "removeRedundantPoints", false) && !is_length(id, "removeUnpainted", false), "{id}");
// Scale Strokes & Effects scales the tolerance with the geometry it is refit to.
let mut e = crate::new_effect(id, &json!({"precision": 0.5, "removeUnpainted": true})).unwrap();
crate::scale_effect(&mut e, 4.0);
assert_eq!(e.params["precision"].as_f64(), Some(2.0), "{id}");
assert_eq!(e.params["removeUnpainted"], json!(true), "{id}");
// An effect saved without the options scales the precision it evaluates with.
let mut e = crate::new_effect(id, &json!({})).unwrap();
crate::scale_effect(&mut e, 3.0);
let scaled = e.params["precision"].as_f64().unwrap_or(f64::NAN);
assert!((scaled - PathfinderEffectOptions::default().precision * 3.0).abs() < 1e-12, "{id}: {scaled}");
// A scale past the range and its inverse restore the precision, as with other distances.
let mut e = crate::new_effect(id, &json!({"precision": 8.0})).unwrap();
crate::scale_effect(&mut e, 2.0);
crate::scale_effect(&mut e, 0.5);
assert_eq!(e.params["precision"].as_f64(), Some(8.0), "{id}");
}
}
+3
View File
@@ -890,6 +890,9 @@ pub use compoundshape::OPEN_PATHS_ADD_NO_AREA;
/// Pathfinder Options (`Prefs::pathfinder`).
pub use pathops::{PATHFINDER_PRECISION_RANGE, PathfinderOptions};
/// The Pathfinder Options a new Pathfinder effect takes (`effect.apply`).
pub use effectcmd::pathfinder_effect_options;
/// The Attributes panel's state ([`Session::attributes_info`]) and how many recent URLs it keeps.
pub use attributes::RECENT_URLS;
pub use overprint::AttributesInfo;
@@ -109,11 +109,11 @@ impl<'a> Reader<'a> {
Ok(union(parts))
}
}
NodeKind::Image(im) => {
let (w, h) = (f64::from(im.width), f64::from(im.height));
let corners = [Point::new(0.0, 0.0), Point::new(w, 0.0), Point::new(w, h), Point::new(0.0, h)].map(|p| im.xf * p);
self.polygon(&corners)
}
// A distorted image's frame joins its corners.
NodeKind::Image(_) => match n.image_corners() {
Some(corners) => self.polygon(&corners),
None => Ok(None),
},
// An instance of a symbol the document doesn't have draws nothing.
NodeKind::SymbolInstance { .. } => match vectorcraft_render::effects::outline_object(Some(self.doc), n) {
Some(art) => self.node(&art, depth + 1),
@@ -663,6 +663,29 @@ fn an_image_is_measured_by_its_frame_as_turned() {
assert!((end - (300.0 - (y - (300.0 - half)))).abs() < 0.01, "{end} at {y}");
}
#[test]
fn a_distorted_image_is_measured_by_the_frame_through_its_corners() {
let mut s = session();
let im = vectorcraft_doc::ImageObject {
key: "image".into(),
width: 100,
height: 100,
xf: Affine::IDENTITY,
link: None,
placement: Default::default(),
pixels: None,
};
insert(&mut s, |id| {
let mut n = Node::new(id, NodeKind::Image(Box::new(im)));
n.set_image_corners([Point::new(40.0, 0.0), Point::new(60.0, 0.0), Point::new(100.0, 100.0), Point::new(0.0, 100.0)]).unwrap();
n
});
let (b, end) = diamond_weeding(&mut s);
assert!((b.x0 + 10.0).abs() < 1e-3 && (b.y1 - 110.0).abs() < 1e-3, "{b:?}");
// A quarter of the box down (y = 20), the line meets the side from (40, 0) to (0, 100).
assert!((end - 32.0).abs() < 0.01, "{end}");
}
#[test]
fn a_placed_file_is_measured_by_the_art_it_shows() {
let dir = crate::tests_links::Folder::new("weed-placed");
+44 -3
View File
@@ -186,6 +186,7 @@ pub const BUILTIN: &[BuiltinBrushLibrary] = &[
BuiltinBrushLibrary { id: "engraving", name: "Engraving", make: engraving },
BuiltinBrushLibrary { id: "arrows", name: "Arrows", make: arrows },
BuiltinBrushLibrary { id: "image-brush", name: "Image Brush", make: image_brush },
BuiltinBrushLibrary { id: "artistic", name: "Artistic Brushes", make: artistic },
BuiltinBrushLibrary { id: "vector-packs", name: "Vector Packs", make: vector_packs },
];
@@ -240,6 +241,42 @@ fn art(name: &str, art: Node, colorization: Colorization) -> Brush {
Brush { name: name.into(), kind: BrushKind::Art(ArtBrush { art, colorization, ..Default::default() }) }
}
/// Artistic: four original vector compositions that stretch along a path and take its color.
fn artistic() -> BrushLibrary {
let orbit = group(vec![
black(band(100.0, 1.4, 64, |x| 3.0 * (x * std::f64::consts::TAU / 40.0).sin())),
black(band(100.0, 1.4, 64, |x| -3.0 * (x * std::f64::consts::TAU / 40.0).sin())),
]);
let mut petals = vec![black(band(100.0, 0.8, 4, |_| 0.0))];
for i in 0..6 {
let x = 9.0 + 16.0 * i as f64;
let side = if i % 2 == 0 { 1.0 } else { -1.0 };
petals.push(black(polygon(&[(x - 6.0, 0.0), (x - 2.0, 5.0 * side), (x + 5.0, 7.0 * side), (x + 2.0, 2.0 * side)])));
}
let mut lattice = vec![black(band(100.0, 0.9, 4, |_| 0.0))];
for i in 0..5 {
let x = 20.0 * i as f64;
lattice.push(black(polygon(&[(x, -4.0), (x + 1.0, -4.0), (x + 20.0, 4.0), (x + 19.0, 4.0)])));
lattice.push(black(polygon(&[(x, 4.0), (x + 1.0, 4.0), (x + 20.0, -4.0), (x + 19.0, -4.0)])));
}
let mut facets = Vec::new();
for i in 0..8 {
let x = 12.5 * i as f64;
let high = if i % 2 == 0 { 6.0 } else { 3.5 };
facets.push(black(polygon(&[(x, -high), (x + 11.0, -high / 2.0), (x + 12.5, 0.0), (x + 11.0, high / 2.0), (x, high)])));
}
built(
"Artistic Brushes",
Document::new(100.0, 100.0),
vec![
art("Orbit Lines", orbit, Colorization::Tints),
art("Petal Garland", group(petals), Colorization::Tints),
art("Lattice Braid", group(lattice), Colorization::Tints),
art("Facet Sweep", group(facets), Colorization::Tints),
],
)
}
/// Original fine-line art for an engraving-style brush library.
fn engraving() -> BrushLibrary {
let lines = |count: usize, width: f64, spacing: f64| {
@@ -1109,10 +1146,14 @@ pub fn library(s: &Session, key: &str) -> Option<(LibraryInfo, Arc<BrushLibrary>
return Some(found);
}
if let Some(b) = BUILTIN.iter().find(|b| b.id == key) {
return Some((builtin_info(b), builtin_library(key)?));
return Some((builtin_info(b), builtin_library(b.id)?));
}
let id = libraries(s).into_iter().find(|l| l.name.eq_ignore_ascii_case(key))?.id;
library(s, &id)
if let Some(id) = libraries(s).into_iter().find(|l| l.name.eq_ignore_ascii_case(key)).map(|l| l.id) {
return library(s, &id);
}
// Keep the short built-in alias, but let a user or loaded library own its display name.
let b = key.eq_ignore_ascii_case("Artistic").then(|| BUILTIN.iter().find(|b| b.id == "artistic")).flatten()?;
Some((builtin_info(b), builtin_library(b.id)?))
}
fn library_param(s: &Session, p: &Value, cmd: &str) -> Result<(LibraryInfo, Arc<BrushLibrary>)> {
+2 -2
View File
@@ -362,7 +362,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Symbol Sprayer",
[],
None,
"{points: [[x,y]…] (a third number is not used; one that isn't a number is an error), name?, radius?: 40, density?: 1..10 (5), scale?: 1, alt?: bool (remove instances), attributes?: {scrunch?, size?, spin?, screen?, stain?, style?: average|userDefined (average)}, color? (#rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill), style?: name} spray instances into a symbol set → {id, count}. Each of `attributes` says what a new instance takes: average, the mean of the selected set's instances within `radius` of the stroke point (their spacing along the stroke, size, rotation, opacity, and the stain or style of the nearest one that has one at the mean amount), and with none there the symbol's size, no rotation, full opacity and no stain or style; or userDefined: spacing from the symbol's size and `density`, the symbol's size times `scale`, turned the way the stroke runs there (not turned for one point), full opacity, stained in full with `color` (default: the fill color), and the fill of graphic style `style` (default: the first style after the default one) in full; a `style` the document does not have is then an error. The stain and the style are both the instance's fill, and the style replaces the stain. Another key or value in `attributes` is an error",
"{points: [[x,y]…] (a third value is a number or null and is not used), name?, radius?: 40, density?: 1..10 (5; a number outside 1..10 is taken as the nearer end), scale?: 1, alt?: bool (remove instances), attributes?: {scrunch?, size?, spin?, screen?, stain?, style?: average|userDefined (average)}, color? (#rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill), style?: name} spray instances into a symbol set → {id, count}. Each of `attributes` says what a new instance takes: average, the mean of the selected set's instances within `radius` of the stroke point (their spacing along the stroke, size, rotation, opacity, and the stain or style of the nearest one that has one with an amount above 0, at the mean amount), and with none there the symbol's size, no rotation, full opacity and no stain or style; or userDefined: spacing from the symbol's size and `density`, the symbol's size times `scale`, turned the way the stroke runs there (not turned for one point), full opacity, stained in full with `color` (default: the fill color), and the fill of graphic style `style` (default: the first style after the default one) in full; a `style` the document does not have is then an error. The stain and the style are both the instance's fill, and the style replaces the stain. Another key or value in `attributes` is an error",
has_doc,
symbol_spray
),
@@ -380,7 +380,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Symbolism Tool",
[],
None,
"{tool: shift|scrunch|size|spin|stain|screen|style, points: [[x,y,pressure?]…] (pen pressure 0..1, default 1), radius?: 40, intensity?: 1..10 (5), usePressure?: bool (each point's pressure is the intensity there, in place of `intensity`), method?: userDefined|average|random (userDefined; not used by shift), proportional?: bool (size; true), affectsDensity?: bool (size; false), alt?: bool, color? (#rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill), style?: name} adjust instances near the points (selection, else all) → {count}. `method` userDefined changes each instance by the tool's amount at its distance from the point; random gives each instance its own share of that amount for the whole stroke, from none to twice it (spin: a turn either way); average moves each instance's value toward the mean of the instances within `radius` of the point (scrunch: its distance from their middle toward their mean distance; size: the geometric mean of their sizes; spin: their mean direction; stain and style: their mean amount; screen: their mean opacity), and `alt` does not reverse it; average leaves an instance without a size (a scale of 0) as it is. With `proportional` false a drag resizes along its own direction (a level drag the width, an upright one the height; the first point takes the direction to the second) and one point resizes both; average resizes both whatever `proportional` is. With `affectsDensity` an instance also moves away from the point as it grows and toward it as it shrinks. An instance counts only when it changes, and no undo step is added when none does (none under the brush, average with each already at the mean, or each already at the tool's limit). A `method` that is none of the three, or a pressure that isn't a number, is an error",
"{tool: shift|scrunch|size|spin|stain|screen|style, points: [[x,y,pressure?]…] (pen pressure 0..1, default 1), radius?: 40, intensity?: 1..10 (5), usePressure?: bool (each point's pressure is the intensity there, in place of `intensity`), method?: userDefined|average|random (userDefined; not used by shift), proportional?: bool (size; true), affectsDensity?: bool (size; false), alt?: bool, shift?: bool (shift, size, stain and style; false), color? (#rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill), style?: name (a graphic style's; left out, or naming no style in the document, the first style after the default one)} adjust instances near the points (selection, else all) → {count}. `method` userDefined changes each instance by the tool's amount at its distance from the point; random gives each instance its own share of that amount for the whole stroke, from none to twice it (spin: a turn either way; style without `shift`: from none to the userDefined amount); average moves each instance's value toward the mean of the instances within `radius` of the point (scrunch: its distance from their middle toward their mean distance; size: the geometric mean of their sizes; spin: their mean direction; stain and style: their mean amount; screen: their mean opacity), and `alt` does not reverse it; average leaves an instance without a size as it is. With `proportional` false a drag resizes along its own direction, the width by the drag's horizontal share and the height by its vertical share (a level drag the width, an upright one the height, a 45° drag both alike; the first point takes the direction to the second) and one point resizes both; average resizes both whatever `proportional` is. With `affectsDensity` an instance also moves away from the point as it grows and toward it as it shrinks. The style goes on by the brush's strength at each sample, and a stroke's samples add up. With `alt` and without `shift`, userDefined and random style remove all of an instance's appearance items under the brush at once, whatever the brush's strength. `shift` is the tool's Shift form: shift brings the instances within `radius` of any point one place forward among their siblings (with `alt`, one place backward), once for the stroke, and does not move them; size keeps the instances where they are, `affectsDensity` included; stain and style keep each instance's amount and move its paint toward `color` or the style (stain by the tool's amount at its distance from the point, style by the brush's strength there), whatever `method` is, and leave an instance without a stain or style as it is, and `alt` has no effect. An instance counts only when it changes, and no undo step is added when none does (none under the brush, average with each already at the mean, each already at the tool's limit, or shift with nothing to move or change). A `method` that is none of the three, or a pressure that isn't a number, is an error",
has_doc,
symbol_adjust
),
+7 -3
View File
@@ -86,8 +86,9 @@ pub(super) fn spacing(density: f64) -> f64 {
}
/// The document key that holds each symbol set's Symbol Set Density: `{set id: density}`, written
/// when the Symbol Sprayer creates a set and when `symbol.setDensity` spaces it.
const SET_DENSITY_KEY: &str = "symbolSetDensity";
/// when the Symbol Sprayer creates a set and when `symbol.setDensity` spaces it, and copied to a
/// copy of a set by [`Document::reid`].
const SET_DENSITY_KEY: &str = Document::SYMBOL_SET_DENSITY_KEY;
/// The Symbol Set Density symbol set `set` was created at or last given (None when not recorded).
fn set_density_of(d: &Document, set: NodeId) -> Option<f64> {
@@ -261,7 +262,10 @@ pub(super) fn mean(looks: &[&Look], at: Point, with_gap: bool) -> Option<Mean> {
cos += l.angle.cos();
opacity += l.opacity;
middle += l.center.to_vec2();
if let Some((p, o)) = &l.fill {
// A fill at no opacity shows nothing: it is no stain or style, and its paint is not taken.
if let Some((p, o)) = &l.fill
&& *o > 0.0
{
amount += o;
let far = l.center.distance(at);
if paint.is_none_or(|(_, nearest)| far < nearest) {
+174 -32
View File
@@ -118,6 +118,20 @@ fn instances_of(d: &Document, name: Option<&str>) -> Vec<NodeId> {
v
}
/// The symbol instances in `nodes` and inside them, each once, in the order a walk of each node in
/// turn first reaches them.
fn instances_in<'a>(nodes: impl IntoIterator<Item = &'a Node>) -> Vec<NodeId> {
let (mut v, mut seen) = (vec![], std::collections::HashSet::new());
for n in nodes {
n.walk(&mut |c| {
if matches!(c.kind, NodeKind::SymbolInstance { .. }) && seen.insert(c.id) {
v.push(c.id);
}
});
}
v
}
/// The symbols an instance in `n` (its opacity masks included) places, pushed onto `out`.
fn art_symbols(n: &Node, out: &mut Vec<String>) {
vectorcraft_doc::swatches::walk_with_masks(n, &mut |m| {
@@ -917,11 +931,12 @@ fn samples(p: &Value, cmd: &str) -> Result<Vec<(Point, f64)>> {
let a = p.get("points").and_then(Value::as_array).ok_or_else(|| bad(cmd, "missing points [[x,y]…]"))?;
let mut v = Vec::with_capacity(a.len());
for q in a {
let (Some(x), Some(y)) = (q.get(0).and_then(Value::as_f64), q.get(1).and_then(Value::as_f64)) else { continue };
// The pressure is checked first: a point skipped for its coordinates still has a bad one refused.
let pressure = match q.get(2) {
None | Some(Value::Null) => 1.0,
Some(f) => f.as_f64().filter(|f| f.is_finite()).ok_or_else(|| bad(cmd, format!("a point's pressure must be a number, not {f}")))?,
};
let (Some(x), Some(y)) = (q.get(0).and_then(Value::as_f64), q.get(1).and_then(Value::as_f64)) else { continue };
v.push((Point::new(x, y), pressure.clamp(0.0, 1.0)));
}
if v.is_empty() || v.iter().any(|(q, _)| !q.x.is_finite() || !q.y.is_finite()) {
@@ -930,13 +945,15 @@ fn samples(p: &Value, cmd: &str) -> Result<Vec<(Point, f64)>> {
Ok(v)
}
/// The fill of the graphic style `p` names with `style`, else of the document's first style after
/// the default one.
/// The fill of the graphic style `p` names with `style`, else (no name, or one the document has no
/// style for, such as the Symbol Styler's style from another document) of the document's first
/// style after the default one.
fn style_paint(d: &Document, p: &Value) -> Option<Paint> {
match str_param(p, "style") {
Some(n) => d.graphic_styles.iter().find(|g| g.name == n).map(|g| g.appearance.fill_paint()),
None => d.graphic_styles.get(1).or(d.graphic_styles.first()).map(|g| g.appearance.fill_paint()),
}
str_param(p, "style")
.and_then(|n| d.graphic_styles.iter().find(|g| g.name == n))
.or(d.graphic_styles.get(1))
.or(d.graphic_styles.first())
.map(|g| g.appearance.fill_paint())
}
/// Deterministic per-point jitter in [-1, 1]² (so previews re-applied on the snapshot agree).
@@ -976,7 +993,7 @@ pub(super) fn symbol_spray(s: &mut Session, p: &Value) -> Result<Value> {
}
let style = style_paint(&st.doc, p);
// Style: User Defined uses the style `style` names, so one the document does not have is an error.
if let Some(n) = str_param(p, "style").filter(|_| !modes.style && style.is_none()) {
if let Some(n) = str_param(p, "style").filter(|n| !modes.style && !st.doc.graphic_styles.iter().any(|g| g.name == *n)) {
return Err(bad(C, format!("unknown graphic style `{n}`")));
}
let size = natural_size(&st.doc, &name);
@@ -1129,6 +1146,7 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
let use_pressure = switch_or(p, "usePressure", false, C)?;
let proportional = switch_or(p, "proportional", true, C)?;
let affects_density = switch_or(p, "affectsDensity", false, C)?;
let shift = switch_or(p, "shift", false, C)?;
// The Symbol Shifter has no Method.
let method = if tool == "shift" { method_param(p, C).map(|_| Method::UserDefined)? } else { method_param(p, C)? };
// Refused while an object of a dynamic instance's art is selected: the instance stays as it is.
@@ -1141,20 +1159,8 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
let style_paint = style_paint(&st.doc, p);
let candidates: Vec<NodeId> = {
let d = &st.doc;
let mut v = vec![];
if st.selection.is_empty() {
v = instances_of(d, None);
} else {
for id in &st.selection.objects {
if let Some(n) = d.node(*id) {
n.walk(&mut |c| {
if matches!(c.kind, NodeKind::SymbolInstance { .. }) && !v.contains(&c.id) {
v.push(c.id);
}
});
}
}
}
let mut v =
if st.selection.is_empty() { instances_of(d, None) } else { instances_in(st.selection.objects.iter().filter_map(|id| d.node(*id))) };
let editable = d.editable();
v.retain(|id| editable(*id));
v
@@ -1172,12 +1178,39 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
// for the whole stroke (and for every preview of it).
let first = pts.first().map_or(Point::ZERO, |(q, _)| *q);
let share = |id: NodeId| if method == Method::Random { jitter(id.0 as usize, first).0 + 1.0 } else { 1.0 };
// Shift with the Symbol Shifter: the instances under the brush come one place forward among
// their siblings (with `alt`, go one place backward), once for the whole stroke.
if tool == "shift" && shift {
let count = crate::cmd::colorcmds::edit_if_changed(s, label, |_, d| {
let under: std::collections::HashSet<NodeId> = candidates
.iter()
.copied()
.filter(|id| {
d.node(*id).and_then(instance_center).is_some_and(|c| {
pts.iter().any(|(q, pressure)| (if use_pressure { *pressure } else { intensity }) > 0.0 && c.distance(*q) < radius)
})
})
.collect();
let moved = restack(d, &under, alt)?;
Ok((moved, moved > 0))
})?;
return Ok(json!({ "count": count }));
}
// Shift with the Symbol Stainer or the Symbol Styler: the paint an instance's stain or style
// moves toward, and the share of the brush's strength it moves by. Shift with the Symbol Sizer
// keeps the instances where they are, Resizing Affects Density included.
let recolor = match tool.as_str() {
"stain" if shift => Some((Paint::solid(color), 0.15)),
"style" if shift => Some((style_paint.clone().unwrap_or(Paint::solid(color)), 1.0)),
_ => None,
};
let spread = affects_density && !shift;
// No undo step when no instance changes (none under the brush, or Average with each at the mean).
let count = crate::cmd::colorcmds::edit_if_changed(s, label, |orig, d| {
let mut touched = std::collections::BTreeSet::new();
let mut sides = Sides::new();
for (j, (q, pressure)) in pts.iter().enumerate() {
let delta = if j > 0 { *q - pts[j - 1].0 } else { Vec2::ZERO };
let delta = j.checked_sub(1).and_then(|i| pts.get(i)).map_or(Vec2::ZERO, |(prev, _)| *q - *prev);
// Use Pressure Pen: the pen's pressure at the point is the intensity there.
let strength = if use_pressure { *pressure } else { intensity };
// Average: the mean of the instances under the brush, as they are at this point.
@@ -1198,6 +1231,14 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
if w <= 0.0 {
continue;
}
// Shift with the Symbol Stainer or the Symbol Styler: the instance keeps the amount
// of its stain or style, and its paint moves toward the color or the style. An
// instance without one, or without a size, is left as it is.
if let Some((to, step)) = &recolor {
let fill = d.node(*id).and_then(|n| look(d, n, &mut sides)).and_then(|l| l.fill);
touched.extend(recolor_keeping_amount(d, *id, fill, to, step * w).then_some(*id));
continue;
}
// Average needs the instance's own values, so it leaves an instance without a size
// as it is; the other methods change it as before.
// The instance's own values are read for Average only.
@@ -1261,8 +1302,9 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
};
n.transform(about(Affine::scale_non_uniform(kx, ky)), false);
// Resizing Affects Density: instances move away from the brush's center as
// they grow and toward it as they shrink.
if affects_density {
// they grow and toward it as they shrink. Shift keeps the instances where
// they are, so the set's density stays as it was.
if spread {
n.transform(Affine::translate((c - *q) * ((kx * ky).sqrt() - 1.0)), false);
}
}
@@ -1280,9 +1322,10 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
"stain" | "style" => {
let paint = if tool == "style" { style_paint.clone().unwrap_or(Paint::solid(color)) } else { Paint::solid(color) };
let (paint, o) = match &avg {
// Toward the mean amount, keeping the stain or style the instance has.
// Toward the mean amount, keeping the stain or style the instance has
// (one at no opacity is none).
Some((t, look)) => {
let (own, cur) = look.fill.clone().map_or((None, 0.0), |(p, o)| (Some(p), o));
let (own, cur) = look.fill.clone().filter(|(_, o)| *o > 0.0).map_or((None, 0.0), |(p, o)| (Some(p), o));
(own.or(t.paint.clone()).unwrap_or(paint), (cur + (t.amount - cur) * w.min(1.0)) as f32)
}
// Alt with the Symbol Styler removes the instance's appearance.
@@ -1292,11 +1335,11 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
}
None => {
let cur = n.appearance.fill().filter(|f| f.paint == paint).map(|f| f.opacity).unwrap_or(0.0);
// The style goes on gradually, by the brush's strength there: in
// full at the center at full intensity or pressure.
let step = match (tool.as_str(), method) {
// Random: the instance's share of the style, scaled by the
// brush strength there.
("style", Method::Random) => (share / 2.0 * w.min(1.0)) as f32,
("style", _) => 1.0,
("style", Method::Random) => (w * share / 2.0) as f32,
("style", _) => w as f32,
_ => (0.15 * w * share) as f32,
};
(paint, if alt { cur - step } else { cur + step })
@@ -1324,9 +1367,108 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result<Value> {
}
}
}
// An instance the stroke moved away and back again is not counted.
// An instance the stroke moved away and back again, or reached but left as it was (at a
// limit already), is not counted.
touched.retain(|id| d.node(*id) != orig.node(*id));
Ok((touched.len(), !touched.is_empty()))
})?;
Ok(json!({ "count": count }))
}
/// Move the paint of instance `id`'s stain or style (`fill`, its topmost fill with the amount)
/// toward `to` by `t`. The fill keeps its amount and everything else it has, and the instance's
/// other appearance items stay as they are. A paint with no form between it and `to` (a solid
/// color and a pattern, say) takes `to` at once, so repeated strokes below half strength still
/// reach it. An instance without a stain or style, or one whose paint does not change, is left as
/// it is. Returns whether it changed.
fn recolor_keeping_amount(d: &mut Document, id: NodeId, fill: Option<(Paint, f64)>, to: &Paint, t: f64) -> bool {
use vectorcraft_doc::blend::lerp_paint;
let Some((own, _)) = fill.filter(|(_, o)| *o > 0.0) else { return false };
let t = t.clamp(0.0, 1.0) as f32;
let mut paint = lerp_paint(&own, to, t);
// `lerp_paint` switches such a pair halfway, so just below half it still gives `own`.
if paint == own && t > 0.0 && lerp_paint(&own, to, 0.49) == own {
paint = to.clone();
}
if paint == own {
return false;
}
let Some(f) = d.node_mut(id).and_then(|n| n.appearance.fill_mut()) else { return false };
f.paint = paint;
true
}
/// Bring each of `ids` one place forward among its siblings past a sibling that is not one of them
/// (`back`: one place backward). Ones already in front of (behind) every other sibling stay, and
/// so do the clipping path of a clip group and the ruler guides above a layer's art. Returns how
/// many moved.
fn restack(d: &mut Document, ids: &std::collections::HashSet<NodeId>, back: bool) -> Result<usize> {
let parents: std::collections::BTreeSet<Option<NodeId>> = ids.iter().map(|id| d.parent_of(*id)).collect();
let mut moved = 0;
for par in parents {
let floor = usize::from(par.and_then(|p| d.node(p)).is_some_and(Node::clips));
let ch = d.children_mut(par)?;
let len = Node::guide_run_start(ch);
if len <= floor + 1 {
continue;
}
let picked = |n: &Arc<Node>| ids.contains(&n.id);
if back {
for i in floor + 1..len {
if picked(&ch[i]) && !picked(&ch[i - 1]) {
ch.swap(i - 1, i);
moved += 1;
}
}
} else {
for i in (floor..len - 1).rev() {
if picked(&ch[i]) && !picked(&ch[i + 1]) {
ch.swap(i, i + 1);
moved += 1;
}
}
}
}
Ok(moved)
}
#[cfg(test)]
mod tests {
use super::*;
fn instance(id: u64) -> Arc<Node> {
Arc::new(Node::new(NodeId(id), NodeKind::SymbolInstance { symbol: "Dot".into(), xf: Affine::IDENTITY }))
}
/// The instances come out in the order a search of the list built so far gives: nested
/// groups, a group listed twice, a member listed after its group and one listed before it.
#[test]
fn instances_in_matches_searching_the_list_so_far() {
let groups: Vec<Node> = (0..40u64)
.map(|g| {
let base = g * 100;
let mut children: Vec<Arc<Node>> = (0..40).map(|i| instance(base + i)).collect();
let inner = (40..50).map(|i| instance(base + i)).collect();
children.insert(20, Arc::new(Node::group(NodeId(base + 90), inner)));
children.push(Arc::new(Node::group(NodeId(base + 91), vec![])));
Node::group(NodeId(base + 99), children)
})
.collect();
let early = Node::new(NodeId(1_245), NodeKind::SymbolInstance { symbol: "Dot".into(), xf: Affine::IDENTITY });
let late = Node::new(NodeId(305), NodeKind::SymbolInstance { symbol: "Dot".into(), xf: Affine::IDENTITY });
let nodes: Vec<&Node> = std::iter::once(&early).chain(&groups).chain([&groups[0], &late, &groups[7]]).collect();
let mut searched = vec![];
for n in &nodes {
n.walk(&mut |c| {
if matches!(c.kind, NodeKind::SymbolInstance { .. }) && !searched.contains(&c.id) {
searched.push(c.id);
}
});
}
let found = instances_in(nodes.iter().copied());
assert_eq!(found, searched);
assert_eq!(found.len(), 2_000);
assert_eq!(found[0], NodeId(1_245));
assert!(instances_in([]).is_empty());
}
}
+12 -2
View File
@@ -58,9 +58,10 @@ fn view_param(cmd: &str, p: &Value) -> Result<Option<TraceView>> {
v.as_str().and_then(TraceView::from_id).map(Some).ok_or_else(|| bad(cmd, format!("view must be one of {}", ids())))
}
/// The `split` param (the Split view's divider, 0 to 1), if given.
/// The `split` param (the Split view's divider, 0 to 1), if given. A null divider is an error, as
/// any other value that is not such a number is; only an omitted one keeps the divider.
fn split_param(cmd: &str, p: &Value) -> Result<Option<f64>> {
let Some(v) = p.get("split").filter(|v| !v.is_null()) else { return Ok(None) };
let Some(v) = p.get("split") else { return Ok(None) };
v.as_f64().filter(|f| (0.0..=1.0).contains(f)).map(Some).ok_or_else(|| bad(cmd, "split must be a number from 0 to 1"))
}
@@ -649,7 +650,16 @@ fn prepare(s: &Session, c: &str, p: &Value) -> Result<Prepared> {
None if is(tr::preset(named)) || is(tr::enhanced_preset(named)) => named.to_string(),
None => "Custom".to_string(),
};
// The image (inside a trace group, or selected directly).
let (target, image) = target_image(s, c, p)?;
// The traced shapes are placed by the image's transform, which a distortion overrides: the
// command stops before any pixels are read.
let distorted = s.doc()?.doc.node(target).is_some_and(|n| {
n.is_distorted_image() || (is_trace_group(n) && n.children().and_then(|c| c.first()).is_some_and(|i| i.is_distorted_image()))
});
if distorted {
return Err(crate::cmd::xform::distorted_image_error(c, target));
}
if by_color && s.doc()?.doc.node(target).is_some_and(vectorcraft_render::effects::has_pathfinder) {
return Err(bad(c, LIVE_PATHFINDER_BY_COLOR));
}
+4
View File
@@ -109,6 +109,9 @@ pub struct Clipboard {
/// The selected ruler guides copied with (or without) the objects (#3226), as canvas guides on
/// no layer: pasting puts them on the layer new art goes to, moved as the objects are.
pub guides: Vec<vectorcraft_doc::Guide>,
/// The Symbol Set Density recorded at Copy for each copied symbol set, by its id in
/// [`Self::nodes`]: a pasted set packs from it.
pub set_densities: BTreeMap<NodeId, Value>,
/// The RGB and CMYK profiles the objects' colors showed through in the document they were
/// copied from (its assigned profiles, else the working spaces then), by name; none for objects
/// from outside an open document. Paste compares them with the destination's
@@ -484,6 +487,7 @@ impl Clipboard {
})
.collect(),
guides: self.guides.clone(),
set_densities: self.set_densities.clone(),
source_profiles: self.source_profiles.clone(),
colors_converted: self.colors_converted,
}
@@ -1161,6 +1161,7 @@ impl Clipboard {
char_styles: pick(Res::CharStyle, &src.char_styles),
para_styles: pick(Res::ParaStyle, &src.para_styles),
brushes,
set_densities: src.set_densities_of(&nodes),
nodes,
..Default::default()
}
+10 -5
View File
@@ -84,7 +84,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Convert Color",
[],
None,
"{color (#rrggbbaa and #rgba are refused), to: \"rgb\"|\"cmyk\"|\"gray\"|\"lab\", intent?} → {model, values, hex, lab: [L,a,b], outOfGamut, deltaE}",
"{color (#rrggbbaa and #rgba are refused), to: \"rgb\"|\"cmyk\"|\"gray\"|\"lab\"|\"oklch\", intent?} → {model, values, hex, lab: [L,a,b], outOfGamut, deltaE}; oklch values are [L (0..100 %), C, H (0..360°)] of the color's display sRGB (CSS Color 4 OKLCH: https://www.w3.org/TR/css-color-4/#specifying-oklab-oklch), with H 0 for a gray; a color outside sRGB (a Lab color, a CMYK color or an RGB color in a wider working RGB space) is clipped to sRGB first",
always,
convert_color
),
@@ -1362,10 +1362,15 @@ fn convert_color(_: &mut Session, p: &Value) -> Result<Value> {
let intent = intent_param(p, C)?.unwrap_or(c.settings().intent);
let lab = c.lab(&col);
let (model, vals) = match text_param(p, "to", C)?.unwrap_or("rgb") {
"rgb" => ("rgb", values(&c.convert(&col, Model::Rgb, intent))),
"cmyk" => ("cmyk", values(&c.convert(&col, Model::Cmyk, intent))),
"gray" | "grayscale" => ("gray", values(&c.convert(&col, Model::Gray, intent))),
"lab" => ("lab", vec![lab.l, lab.a, lab.b]),
"rgb" => ("rgb", json!(values(&c.convert(&col, Model::Rgb, intent)))),
"cmyk" => ("cmyk", json!(values(&c.convert(&col, Model::Cmyk, intent)))),
"gray" | "grayscale" => ("gray", json!(values(&c.convert(&col, Model::Gray, intent)))),
"lab" => ("lab", json!([lab.l, lab.a, lab.b])),
"oklch" => {
// RGB numbers past 0..1 ([2, 2, 2]) display clipped, as `hex` reports them.
let [l, ch, h] = vectorcraft_color::oklab::to_oklch(c.display_rgb(&col).map(|v| v.clamp(0.0, 1.0)));
("oklch", json!([l * 100.0, ch, h]))
}
other => return Err(bad(C, format!("unknown model `{other}`"))),
};
let de = c.gamut_error(&col);
+2
View File
@@ -1568,6 +1568,8 @@ fn paste_clip(s: &mut Session, p: &Value, mode: PasteMode, clip: &Clipboard, cho
for xf in placements {
for (k, n) in clip.nodes.iter().enumerate() {
let mut c = d.reid(n);
// A pasted symbol set packs from the density recorded for it at Copy.
d.carry_set_densities(n, &c, &clip.set_densities);
imported.apply(&mut c);
let sc = vectorcraft_doc::Scaling { patterns: mode == PasteMode::Drag, ..Default::default() };
if xf != Affine::IDENTITY {
+58
View File
@@ -442,6 +442,17 @@ fn check_revolve_count(n: &Node, cmd: &str) -> Result<()> {
pub(crate) const ONE_3D: &str = "An object takes one 3D effect. Edit the existing effect's options, or remove it first.";
/// The Pathfinder Options that `effect.apply` gives a Pathfinder effect for the keys its `params`
/// leave out: the preferences' Pathfinder Options in force.
pub fn pathfinder_effect_options(s: &Session) -> effects::PathfinderEffectOptions {
let current = super::pathops::current_pf_options(s);
effects::PathfinderEffectOptions {
precision: current.precision,
remove_redundant_points: current.remove_redundant_points,
remove_unpainted: current.remove_unpainted,
}
}
/// `effect.apply`: adds effect `effect` (or `id`) with `params`, its defaults filled in, to the
/// targets' active item as one undo step. A 3D effect must fit each target, which takes only one;
/// a Pathfinder effect on loose objects groups them first. → `{ids, index, item}`.
@@ -465,10 +476,23 @@ pub(crate) fn apply(s: &mut Session, p: &Value) -> Result<Value> {
super::params::check_effect_color(C, id, &params)?;
super::params::check_effect_channel(C, id, &params)?;
super::params::check_effect_center(C, id, &params)?;
super::params::check_effect_pathfinder(C, id, &params)?;
// Crop Marks take their style from the preferences when applied.
if id == effects::CROP_MARKS && params.get("style").is_none() {
params["style"] = json!(s.crop_mark_style().id());
}
// A Pathfinder effect keeps the Pathfinder Options in force when it is applied, those `params`
// give aside. They join the journal entry, so replaying it gives the same effect.
if effects::takes_pathfinder_options(id) {
if let Value::Object(filled) = pathfinder_effect_options(s).to_params() {
for (key, v) in filled {
if params.get(&key).is_none() {
params[key.as_str()] = v;
}
}
}
s.note_journal("params", params.clone());
}
if texture_load_effect(id) {
load_texture(&mut params, C)?;
}
@@ -789,6 +813,7 @@ pub(crate) fn set_params(s: &mut Session, p: &Value) -> Result<Value> {
super::params::check_effect_color(C, effect, &params)?;
super::params::check_effect_channel(C, effect, &params)?;
super::params::check_effect_center(C, effect, &params)?;
super::params::check_effect_pathfinder(C, effect, &params)?;
}
if edited.iter().any(|e| texture_load_effect(e)) {
load_texture(&mut params, C)?;
@@ -808,6 +833,15 @@ pub(crate) fn set_params(s: &mut Session, p: &Value) -> Result<Value> {
return Ok(json!({ "ids": [] }));
}
}
// Pathfinder effects given the values they already evaluate with, and nothing else to change,
// are no edit and record no undo step.
if kind.is_none() && warp_id.is_none() && visible.is_none() {
let d = &s.doc()?.doc;
let fx: Vec<&Effect> = targets.iter().filter_map(|&(id, at, index)| d.node(id)?.appearance.effects_at(at)?.get(index)).collect();
if !fx.is_empty() && fx.iter().all(|e| pathfinder_edit_changes_nothing(e, &params)) {
return Ok(json!({ "ids": [] }));
}
}
// An SVG filter is named by its id: another filter renames the effect.
if edited.iter().any(|e| e == effects::SVG_FILTER)
&& let Some(xml) = params.get("xml").and_then(Value::as_str)
@@ -876,6 +910,30 @@ pub(crate) fn set_params(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "ids": ids_json(&ids) }))
}
/// Does merging `params` into Pathfinder effect `e` leave it drawing as it does: the same Pathfinder
/// Options ([`effects::PathfinderEffectOptions`], so an effect saved without them and given their
/// defaults is unchanged), each option given equal to the one it stores (a precision that Scale
/// Strokes & Effects took past its range evaluates at the bound but is still edited), and every
/// other value given equal to the one it has?
fn pathfinder_edit_changes_nothing(e: &Effect, params: &Value) -> bool {
if !effects::takes_pathfinder_options(&e.id) {
return false;
}
let Some(given) = params.as_object().filter(|m| !m.is_empty()) else { return true };
let current = effects::merged_params(&e.id, &e.params);
let mut after = current.clone();
if let Value::Object(m) = &mut after {
m.extend(given.clone());
}
let others_same = given.iter().filter(|(k, _)| !effects::PATHFINDER_OPTION_KEYS.contains(&k.as_str())).all(|(k, v)| current.get(k) == Some(v));
let same_value = |a: &Value, b: &Value| a == b || a.as_f64().is_some_and(|x| b.as_f64() == Some(x));
let stored_same = given
.iter()
.filter(|(k, _)| effects::PATHFINDER_OPTION_KEYS.contains(&k.as_str()))
.all(|(k, v)| e.params.get(k).is_none_or(|stored| same_value(stored, v)));
others_same && stored_same && effects::PathfinderEffectOptions::from_params(&current) == effects::PathfinderEffectOptions::from_params(&after)
}
// ---------- Load Texture ----------
/// Effect › Distort › Glass.
+5 -1
View File
@@ -141,7 +141,11 @@ impl Builder {
if fills.is_empty() { Body::Complex } else { Body::Fills { shape: self.shape(path, rule, Kind::Vector)?, fills } }
}
NodeKind::Image(im) => {
let frame = shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf);
// A distorted image's frame joins its corners.
let frame = match n.image_frame().filter(|_| n.is_distorted_image()) {
Some(bp) => PathData::from_bezpath(&bp),
None => shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf),
};
self.shape(frame, FillRule::NonZero, Kind::Other)?;
Body::Complex
}
+49 -1
View File
@@ -1211,6 +1211,16 @@ pub(crate) fn set_image_from_path(d: &mut Document, id: NodeId, path: &str, doc_
install(d, &[id], read, Some(Preserve::Bounds), None)
}
/// Distorted image `im` shows the file read for `link` (`img`) and keeps its corners and its
/// clipping: the new pixels fill them. Its transform is scaled to the new pixel size, so a reader
/// that places it by the transform still gives it its old size.
fn refill_distorted(im: &mut ImageObject, link: &LinkInfo, img: &RasterImage) {
if (img.width, img.height) != (im.width, im.height) && img.width > 0 && img.height > 0 {
im.xf *= Affine::scale_non_uniform(f64::from(im.width) / f64::from(img.width), f64::from(im.height) / f64::from(img.height));
}
(im.key, im.width, im.height, im.link) = (img.key.clone(), img.width, img.height, Some(link.clone()));
}
/// Image objects `ids` (in the layers or outside them) show the file read for `link` (`img`), each
/// placed as its Placement Options say (`force`: as that Preserve choice says, whatever they say);
/// with `also` (a file's path and the content shown), so do the images outside the layer tree that
@@ -1235,7 +1245,12 @@ fn install(d: &mut Document, ids: &[NodeId], (link, img): FileRead, force: Optio
let mut make = |n: &Node, held: Option<(&PathData, FillRule)>| {
let mut n = n.clone();
let mut clip = ClipTo::Keep;
let distorted = n.is_distorted_image();
if let NodeKind::Image(im) = &mut n.kind {
if distorted {
refill_distorted(im, &link, &img);
return (n, clip);
}
let o = PlacementOptions { preserve: force.unwrap_or(im.placement.preserve), ..im.placement };
let size = |w: u32, h: u32| (w as f64, h as f64);
let (old_pt, old_clip) = match old.get(&im.key) {
@@ -1251,6 +1266,14 @@ fn install(d: &mut Document, ids: &[NodeId], (link, img): FileRead, force: Optio
Nested { pick: &pick, make: &mut make, next: 0 }.run(d);
}
for id in ids {
if d.node(*id).is_some_and(Node::is_distorted_image) {
if let Some(n) = d.node_mut(*id)
&& let NodeKind::Image(im) = &mut n.kind
{
refill_distorted(im, &link, &img);
}
continue;
}
let Some(NodeKind::Image(im)) = d.node(*id).map(|n| &n.kind) else { continue };
let o = PlacementOptions { preserve: force.unwrap_or(im.placement.preserve), ..im.placement };
let size = |w: u32, h: u32| (w as f64, h as f64);
@@ -2068,6 +2091,9 @@ fn relink(s: &mut Session, p: &Value) -> Result<Value> {
_ => None,
})
};
// Whether the images were found as the missing links (nothing selected, a folder given) rather
// than named or selected.
let mut found_missing = false;
let mut ids: Vec<NodeId> = match (&each, ids_param(p, "ids", C)?) {
(Some(each), _) => each.iter().flat_map(|(ids, _)| ids.iter().copied()).collect(),
(None, Some(ids)) => ids,
@@ -2075,6 +2101,7 @@ fn relink(s: &mut Session, p: &Value) -> Result<Value> {
let selected: Vec<NodeId> = st.selection.objects.iter().copied().filter(|id| image(id).is_some()).collect();
match folder_param {
Some(_) if selected.is_empty() => {
found_missing = true;
groups(&st.doc, None).into_iter().filter(|g| probe(g, LinkBase::of(st)).0 == Status::Missing).flat_map(|g| g.ids).collect()
}
_ => selected,
@@ -2087,6 +2114,11 @@ fn relink(s: &mut Session, p: &Value) -> Result<Value> {
if ids.is_empty() {
return Err(bad(C, "select the images to relink, or pass ids"));
}
// A named or selected distorted image is refused before a folder is searched, whether or not
// its file is found there.
if !found_missing && let Some(id) = ids.iter().find(|id| stored(&doc, **id).is_some_and(Node::is_distorted_image)) {
return Err(super::xform::distorted_image_error(C, *id));
}
// All Instances: the other stored objects linked to the same files, each once.
if scope == Scope::All {
let paths: BTreeSet<&str> = ids.iter().filter_map(|id| image(id).flatten()).map(|l| l.path.as_str()).collect();
@@ -2131,6 +2163,11 @@ fn relink(s: &mut Session, p: &Value) -> Result<Value> {
}
(None, None, None) => return Err(bad(C, "give path (a file) or folder")),
}
// A new file's placement options place a plain image: a distorted one is left as it is.
let distorted = files.iter().flat_map(|(ids, _)| ids).find(|id| stored(&doc, **id).is_some_and(Node::is_distorted_image));
if let Some(id) = distorted {
return Err(super::xform::distorted_image_error(C, *id));
}
// Every file is read and checked before any is copied.
let mut checked = vec![];
for (ids, path) in files {
@@ -2593,6 +2630,9 @@ fn embed(s: &mut Session, p: &Value) -> Result<Value> {
if ids.is_empty() {
return Err(bad(C, "select the linked images or placed documents, or pass ids"));
}
if let Some(id) = ids.iter().find(|id| stored(&doc, **id).is_some_and(Node::is_distorted_image)) {
return Err(super::xform::distorted_image_error(C, *id));
}
// A DCS file's plates print from its file.
let separated = |id: &NodeId| match kind(id) {
Some(NodeKind::Image(im)) => st.doc.images.get(&im.key).is_some_and(ImageBlob::is_separated),
@@ -2721,6 +2761,9 @@ fn unembed(s: &mut Session, p: &Value) -> Result<Value> {
if im.link.is_some() {
return Err(bad(C, format!("image {} is linked already", id.0)));
}
if n.is_distorted_image() {
return Err(super::xform::distorted_image_error(C, id));
}
let blob = st.doc.images.get(&im.key).filter(|b| !b.is_proxy()).ok_or_else(|| bad(C, "the image's pixels aren't in the document"))?;
// As stored (PNG, JPEG, GIF, WebP), unless the path names another format.
let stored = stored_extension(blob);
@@ -2772,6 +2815,9 @@ fn unembed_to_folder(s: &mut Session, p: &Value, ids: Option<Vec<NodeId>>) -> Re
skipped.push(id);
continue;
}
if n.is_distorted_image() {
return Err(super::xform::distorted_image_error(C, id));
}
let blob = st.doc.images.get(&im.key).filter(|b| !b.is_proxy()).ok_or_else(|| bad(C, "the image's pixels aren't in the document"))?;
embedded.push((id, n.display_name(), blob));
}
@@ -2984,7 +3030,9 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
let (px, py) = file_pt(&st.doc, &im.key);
out["effectivePpi"] = out["ppi"].take();
out["ppi"] = json!([72.0 / px, 72.0 / py]);
(out["scale"], out["rotation"]) = scale_rotation(im.xf, (px, py));
// A distorted image is measured at its middle, as its effective resolution is.
let xf = stored(&doc, id).and_then(vectorcraft_doc::image_quad::nearest_affine).unwrap_or(im.xf);
(out["scale"], out["rotation"]) = scale_rotation(xf, (px, py));
out["format"] = json!(format_label(&st.doc, im));
out["placement"] = placement_json(im.placement);
out["status"] = json!("embedded");
+16
View File
@@ -244,12 +244,22 @@ pub(super) fn spine_move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
Some(_) => return Err(bad(C, "handle must be in or out")),
};
let independent = switch_or(p, "independent", false, C)?;
let symmetric = switch_or(p, "symmetric", false, C)?;
let link = switch_or(p, "link", false, C)?;
let with = spine_points_param(p, C)?;
// Any `with`, even an empty list, asks to move points, which a handle drag doesn't.
if handle.is_some() && p.get("with").is_some_and(|v| !v.is_null()) {
return Err(bad(C, "`with` moves points, not a handle"));
}
if symmetric && independent {
return Err(bad(C, "`independent` and `symmetric` cannot both be true"));
}
if symmetric && handle.is_none() {
return Err(bad(C, "`symmetric` places a handle: give `handle`"));
}
if link && symmetric {
return Err(bad(C, "`link` and `symmetric` cannot both be true"));
}
if link && independent {
return Err(bad(C, "`link` and `independent` cannot both be true"));
}
@@ -264,6 +274,8 @@ pub(super) fn spine_move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
}
edit_spine(s, p, C, "Reshape Spine", |sp, anchors, keys| {
let pull_out = handle.is_some_and(|out| sp.has_segment(index, !out));
// At an open end of the spine the handle moves as it would without `symmetric`.
let symmetric = symmetric && pull_out;
let a = sp.anchors.get_mut(index).ok_or_else(|| bad(C, "no such spine point"))?;
if let Some(out) = handle {
if link {
@@ -271,6 +283,10 @@ pub(super) fn spine_move_anchor(s: &mut Session, p: &Value) -> Result<Value> {
} else {
a.set_handle(out, q, independent);
}
if symmetric {
let opposite = a.p - (q - a.p);
if out { a.h_in = opposite } else { a.h_out = opposite }
}
return Ok(());
}
let delta = q - a.p;
+1 -1
View File
@@ -99,7 +99,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Move Spine Point",
[],
None,
"{id? (default: the selected blend), anchor: index, x, y, with?: [index…], handle?: in|out, independent?: bool, link?: bool} move a point of the blend's spine (its handles along), and the points `with` names by as much, or with `handle` place that handle's end at (x, y) (a smooth point keeps the other handle in line unless `independent`; `link` makes the point smooth with the other handle in line at its own length, a retracted one pulled out to the moved handle's length where a segment leaves the point on its side; `link` needs `handle` and cannot go with `independent`). A key object sitting on a moved point moves with it. The first edit turns the straight spine into a path",
"{id? (default: the selected blend), anchor: index, x, y, with?: [index…], handle?: in|out, independent?: bool, symmetric?: bool, link?: bool} move a point of the blend's spine (its handles along), and the points `with` names by as much, or with `handle` place that handle's end at (x, y) (a smooth point keeps the other handle in line unless `independent`; `symmetric` mirrors the opposite handle about the anchor without changing its kind, except at an open end of the spine; `link` makes the point smooth with the other handle in line at its own length, a retracted one pulled out to the moved handle's length where a segment leaves the point on its side; `symmetric` and `link` need `handle`, `symmetric` cannot go with `independent`, and `link` cannot go with `independent` or `symmetric`; all default false). A key object sitting on a moved point moves with it. The first edit turns the straight spine into a path",
has_doc,
spine_move_anchor
),
+15 -3
View File
@@ -25,14 +25,23 @@ pub(super) fn mesh_create(s: &mut Session, p: &Value) -> Result<Value> {
};
let (rows, cols) = if at.is_some() { (1, 1) } else { (rows, cols) };
let roots = roots_param(s, p)?;
// The distorted images left as they are, each with why.
let mut distorted = vec![];
let (ids, index) = s.edit("Create Gradient Mesh", |d, sel| {
let mut out = vec![];
let mut index = None;
let mut refused = None;
let model = d.color_mode.model();
distorted.clear();
for id in &roots {
let Some(n) = d.node(*id).cloned() else { continue };
let m = if let NodeKind::Image(im) = &n.kind {
if n.is_distorted_image() {
let e = super::super::xform::distorted_image_error(C, *id);
distorted.push(json!({"id": id.0, "reason": e.to_string()}));
refused.get_or_insert(e);
continue;
}
// An embedded image: the points take the picture's colours there.
match image_mesh(d, im, rows, cols) {
Ok(mut m) => {
@@ -40,7 +49,7 @@ pub(super) fn mesh_create(s: &mut Session, p: &Value) -> Result<Value> {
Some(m)
}
Err(why) => {
refused.get_or_insert(why);
refused.get_or_insert_with(|| bad(C, why));
continue;
}
}
@@ -60,7 +69,7 @@ pub(super) fn mesh_create(s: &mut Session, p: &Value) -> Result<Value> {
match m.add_lines_at(q, tol) {
Some(i) => index = Some(i),
None => {
refused.get_or_insert("point is outside the object");
refused.get_or_insert_with(|| bad(C, "point is outside the object"));
continue;
}
}
@@ -75,7 +84,7 @@ pub(super) fn mesh_create(s: &mut Session, p: &Value) -> Result<Value> {
out.push(*id);
}
if out.is_empty() {
return Err(bad(C, refused.unwrap_or("select a path, a compound path or an embedded image")));
return Err(refused.unwrap_or_else(|| bad(C, "select a path, a compound path or an embedded image")));
}
sel.set(out.iter().copied());
Ok((out, index))
@@ -84,6 +93,9 @@ pub(super) fn mesh_create(s: &mut Session, p: &Value) -> Result<Value> {
if let Some(i) = index {
r["index"] = json!(i);
}
if !distorted.is_empty() {
r["skipped"] = json!(distorted);
}
Ok(r)
}
+15 -4
View File
@@ -998,6 +998,9 @@ fn mosaic_plan(s: &Session, p: &Value) -> Result<MosaicPlan> {
.ok_or_else(|| bad(C, "select an image"))?;
let node = st.doc.node(id).ok_or(EngineError::NoNode(id))?;
let NodeKind::Image(im) = &node.kind else { return Err(bad(C, "select an image")) };
if node.is_distorted_image() {
return Err(super::xform::distorted_image_error(C, id));
}
if !st.doc.images.get(&im.key).is_some_and(|b| !b.bytes.is_empty()) {
return Err(bad(C, "the image has no embedded pixels"));
}
@@ -1285,6 +1288,9 @@ fn crop_image(s: &mut Session, p: &Value) -> Result<Value> {
.ok_or_else(|| bad(C, "select an image"))?;
let node = st.doc.node(id).cloned().ok_or(EngineError::NoNode(id))?;
let NodeKind::Image(im) = &node.kind else { return Err(bad(C, "select an image")) };
if node.is_distorted_image() {
return Err(super::xform::distorted_image_error(C, id));
}
if switch_or(p, "trim", false, C)? {
if p.get("ppi").is_some_and(|v| !v.is_null()) {
return Err(bad(C, "trim keeps the image's pixels as they are: leave out ppi"));
@@ -1495,11 +1501,16 @@ fn mask_image(s: &mut Session, _: &Value) -> Result<Value> {
.selection
.objects
.iter()
.find_map(|id| match st.doc.node(*id).map(|n| &n.kind) {
Some(NodeKind::Image(im)) => {
Some((*id, vectorcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf)))
.find_map(|id| {
let n = st.doc.node(*id)?;
match &n.kind {
// A distorted image's outline joins its corners.
NodeKind::Image(_) if n.is_distorted_image() => Some((*id, PathData::from_bezpath(&n.image_frame()?))),
NodeKind::Image(im) => {
Some((*id, vectorcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf)))
}
_ => None,
}
_ => None,
})
.ok_or_else(|| bad("object.maskImage", "select an image"))?;
let (gid, pid) = s.edit("Mask", |d, sel| {
+30 -4
View File
@@ -516,7 +516,30 @@ pub fn check_effect_params(id: &str, effect: &str, params: &Value) -> Result<()>
}
check_effect_color(id, effect, params)?;
check_effect_channel(id, effect, params)?;
check_effect_center(id, effect, params)
check_effect_center(id, effect, params)?;
check_effect_pathfinder(id, effect, params)
}
/// The Pathfinder Options in `params` of a Pathfinder effect (`effect`), as command `id` was given
/// them: `precision` a number of points from 0.001 to 10, and `removeRedundantPoints` and
/// `removeUnpainted` true or false. `effect.apply` and `effect.setParams` run this themselves
/// before they edit, as they run [`check_effect_color`].
pub(crate) fn check_effect_pathfinder(id: &str, effect: &str, params: &Value) -> Result<()> {
use vectorcraft_render::effects;
if !effects::takes_pathfinder_options(effect) {
return Ok(());
}
if let Some(v) = params.get("precision")
&& !v.as_f64().is_some_and(|p| effects::PATHFINDER_EFFECT_PRECISION.contains(&p))
{
return Err(bad(id, "precision must be from 0.001 to 10 pt"));
}
for key in ["removeRedundantPoints", "removeUnpainted"] {
if params.get(key).is_some_and(|v| !v.is_boolean()) {
return Err(bad(id, format!("`{key}` must be true or false")));
}
}
Ok(())
}
/// The type of the values in `params` of effect `effect`, as command `id` was given them: a key
@@ -557,9 +580,10 @@ fn check_effect_types(id: &str, effect: &str, params: &Value) -> Result<()> {
/// A value of the type effect `effect` reads for `key`, a parameter its params description names
/// without a dialog default: the earlier 3D Perspective and light (`perspective`, `lightAzimuth`,
/// `lightElevation`) and Scribble `variation` are numbers, an Outline Stroke's `width` is a number
/// and a Gaussian Blur's `linear` is true or false. A Glass, Texturizer or Rough Pastels
/// `textureImage`, an SVG filter's `name` and `xml`, a Warp's `version` and the `style` of Crop
/// Marks have checks of their own; they aren't listed.
/// and a Gaussian Blur's `linear` is true or false. A Pathfinder effect's `precision` is a number and
/// its `removeRedundantPoints` and `removeUnpainted` are true or false. A Glass, Texturizer or Rough
/// Pastels `textureImage`, an SVG filter's `name` and `xml`, a Warp's `version` and the `style` of
/// Crop Marks have checks of their own; they aren't listed.
pub(crate) fn undefaulted_type(effect: &str, key: &str) -> Option<Value> {
use vectorcraft_render::effects;
let number = || Some(Value::from(0.0));
@@ -568,6 +592,8 @@ pub(crate) fn undefaulted_type(effect: &str, key: &str) -> Option<Value> {
"variation" if effect == "stylize.scribble" => number(),
"width" if effect == "path.outlineStroke" => number(),
"linear" if effect == "blur.gaussian" => Some(Value::Bool(false)),
"precision" if effects::takes_pathfinder_options(effect) => number(),
"removeRedundantPoints" | "removeUnpainted" if effects::takes_pathfinder_options(effect) => Some(Value::Bool(false)),
_ => None,
}
}
+26 -1
View File
@@ -50,7 +50,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Move Direction Handle",
[],
None,
"{id, subpath?, anchor, which: \"in\"|\"out\", x, y, independent?: bool, link?: bool, at?: [x,y]} move a direction handle; independent moves only that side and makes the anchor a corner; link makes the anchor smooth with the other handle in line at its own length (a retracted one is pulled out to the moved handle's length where a segment leaves the anchor on its side); link and independent cannot both be true; both default false; with link false, at moves the anchor and both handles before placing the chosen handle",
"{id, subpath?, anchor, which: \"in\"|\"out\", x, y, independent?: bool, symmetric?: bool, link?: bool, at?: [x,y]} move a direction handle; independent moves only that side and makes the anchor a corner; symmetric mirrors the other handle about the anchor without changing its kind (not at an open end, where no segment leaves the anchor on that side); link makes the anchor smooth with the other handle in line at its own length (a retracted one is pulled out to the moved handle's length where a segment leaves the anchor on its side); independent and symmetric cannot both be true, and link cannot go with either; all default false; with link false, at moves the anchor and both handles before placing the chosen handle",
has_doc,
set_handle
),
@@ -461,6 +461,13 @@ fn set_handle(s: &mut Session, p: &Value) -> Result<Value> {
return link_handle(s, p, id, si, ai, out, pos);
}
let independent = switch_or(p, "independent", false, "path.setHandle")?;
let symmetric = switch_or(p, "symmetric", false, "path.setHandle")?;
if symmetric && independent {
return Err(bad("path.setHandle", "`independent` and `symmetric` cannot both be true"));
}
// The other handle is mirrored only where a segment leaves the anchor on its side: at an open
// end the handle moves as it would without `symmetric`.
let symmetric = symmetric && has_segment(s, id, si, ai, !out)?;
let at = match p.get("at").filter(|v| !v.is_null()) {
None => None,
Some(v) => Some(finite_numbers(v).map(|[x, y]| Point::new(x, y)).ok_or_else(|| bad("path.setHandle", "`at` must be [x, y]"))?),
@@ -472,6 +479,7 @@ fn set_handle(s: &mut Session, p: &Value) -> Result<Value> {
&& at.is_none_or(|to| to == a.p)
&& (if out { a.h_out } else { a.h_in }) == pos
&& !(independent && a.kind != AnchorKind::Corner)
&& (!symmetric || (if out { a.h_in } else { a.h_out }) == a.p - (pos - a.p))
{
return ok();
}
@@ -504,6 +512,10 @@ fn set_handle(s: &mut Session, p: &Value) -> Result<Value> {
} else {
a.set_handle(out, pos, independent);
}
if symmetric {
let opposite = a.p - (pos - a.p);
if out { a.h_in = opposite } else { a.h_out = opposite }
}
Ok(())
})?;
ok()
@@ -519,6 +531,9 @@ fn link_handle(s: &mut Session, p: &Value, id: NodeId, si: usize, ai: usize, out
if switch_or(p, "independent", false, C)? {
return Err(bad(C, "`link` and `independent` cannot both be true"));
}
if switch_or(p, "symmetric", false, C)? {
return Err(bad(C, "`link` and `symmetric` cannot both be true"));
}
if !(pos.x.abs() < 1e9 && pos.y.abs() < 1e9) {
return Err(bad(C, "x and y must be finite"));
}
@@ -655,6 +670,16 @@ fn anchor_of(s: &Session, id: NodeId, si: usize, ai: usize) -> Result<Option<Anc
Ok(d.node(id).and_then(|n| n.path_data()).and_then(|path| path.subpaths.get(si)).and_then(|sp| sp.anchors.get(ai)).copied())
}
/// Whether anchor `ai` of subpath `si` of path `id` has a segment on its outgoing (`out`) or
/// incoming side; false when the path, subpath or anchor is not there.
fn has_segment(s: &Session, id: NodeId, si: usize, ai: usize, out: bool) -> Result<bool> {
if s.script_running() {
return Err(EngineError::Busy);
}
let d = &s.doc()?.doc;
Ok(d.node(id).and_then(|n| n.path_data()).and_then(|path| path.subpaths.get(si)).is_some_and(|sp| sp.has_segment(ai, out)))
}
fn set_anchors(s: &mut Session, p: &Value) -> Result<Value> {
let id = object_param(p, "id", "path.setAnchors")?.ok_or_else(|| bad("path.setAnchors", "missing id"))?;
let subs = p.get("subpaths").and_then(Value::as_array).ok_or_else(|| bad("path.setAnchors", "missing subpaths"))?;
+10 -3
View File
@@ -685,14 +685,21 @@ fn pf_label(op: PathfinderOp) -> &'static str {
}
}
/// The Pathfinder Options an operation uses: those `p` gives, else the preferences'. They join the
/// command's journal entry, so replaying it gives the same result whatever the preferences are then.
fn pf_options(s: &mut Session, p: &Value, id: &str) -> Result<PathfinderOptions> {
/// The Pathfinder Options in the preferences, as the panel's operations and a new Pathfinder effect
/// take them.
pub(crate) fn current_pf_options(s: &Session) -> PathfinderOptions {
let mut stored = s.prefs.pathfinder;
if !PATHFINDER_PRECISION_RANGE.contains(&stored.precision) {
// A preferences file edited by hand: the default, rather than refitting everything away.
stored.precision = po::DEFAULT_PRECISION;
}
stored
}
/// The Pathfinder Options an operation uses: those `p` gives, else the preferences'. They join the
/// command's journal entry, so replaying it gives the same result whatever the preferences are then.
fn pf_options(s: &mut Session, p: &Value, id: &str) -> Result<PathfinderOptions> {
let stored = current_pf_options(s);
let keys = ["precision", "removeRedundantPoints", "removeUnpainted"];
let given: serde_json::Map<String, Value> =
p.as_object().into_iter().flatten().filter(|(k, _)| keys.contains(&k.as_str())).map(|(k, v)| (k.clone(), v.clone())).collect();
+31 -14
View File
@@ -630,19 +630,7 @@ fn at_param(p: &Value) -> Result<Option<Point>> {
/// `image_xf`), also for an image alone in a clip group when the new art is an image, clipped by
/// its file's clipping path or not (`new_image`); other objects keep their centre.
fn replace_xf(d: &Document, old: &Node, natural: Rect, image_xf: bool, new_image: bool) -> Affine {
// An image alone in a clip group (as a PSD or PSB file's clipping path places it,
// [`fileio::file_clipped`]) is measured as the image when the new art is an image; a DCS
// file's plates are not.
let image = match &old.kind {
NodeKind::Group { children, clip: true } if new_image => match &children[..] {
[path, image] if matches!(path.kind, NodeKind::Path { clipping: true, .. }) => match &image.kind {
NodeKind::Image(im) if d.images.get(&im.key).is_none_or(|b| b.separated().is_none()) => image,
_ => old,
},
_ => old,
},
_ => old,
};
let image = replace_measured(d, old, new_image);
if image_xf && let NodeKind::Image(im) = &image.kind {
let (sx, sy) = pt_per_px(d.images.get(&im.key).and_then(|b| fileio::ppi::resolution(&b.bytes)));
let full = Affine::scale_non_uniform(sx, sy);
@@ -655,6 +643,22 @@ fn replace_xf(d: &Document, old: &Node, natural: Rect, image_xf: bool, new_image
Affine::translate(c - natural.center())
}
/// The object [`replace_xf`] measures when Replace swaps `old`: an image alone in a clip group (as
/// a PSD or PSB file's clipping path places it, [`fileio::file_clipped`]) when the new art is an
/// image (`new_image`), except a DCS file's plates; else `old` itself.
fn replace_measured<'a>(d: &Document, old: &'a Node, new_image: bool) -> &'a Node {
match &old.kind {
NodeKind::Group { children, clip: true } if new_image => match &children[..] {
[path, image] if matches!(path.kind, NodeKind::Path { clipping: true, .. }) => match &image.kind {
NodeKind::Image(im) if d.images.get(&im.key).is_none_or(|b| b.separated().is_none()) => image,
_ => old,
},
_ => old,
},
_ => old,
}
}
/// `rect` fitted with `natural`'s aspect, centred.
fn fit(natural: Rect, r: Rect) -> Affine {
let ratio = |a: f64, b: f64| (b > 1e-9).then(|| a / b);
@@ -814,6 +818,17 @@ fn apply(s: &mut Session, read: PlaceRead) -> Result<Value> {
loaded.natural = Rect::from_origin_size(Point::ORIGIN, size);
}
let natural = loaded.natural;
// Replace keeps the transform of the image it measures (`replace_measured`), which a
// distortion's corners do not follow. Type, and any other object it measures, is placed by the
// bounds of what it replaces, so a distorted image there is not refused.
if let Some(o) = old_node
&& !is_text
{
let image = replace_measured(&st.doc, o, matches!(loaded.art, Art::Image(..)));
if image.is_distorted_image() {
return Err(super::xform::distorted_image_error(PLACE, image.id));
}
}
let m = match (old_node, rect) {
(Some(o), _) => replace_xf(&st.doc, o, natural, !is_text, matches!(loaded.art, Art::Image(..))),
(None, Some(r)) => fit(natural, r),
@@ -1173,6 +1188,8 @@ pub(crate) fn image_info(s: &mut Session, p: &Value) -> Result<Value> {
let doc = super::links::with_brush_art(&st.doc);
let n = doc.stored_node(id).map(|(n, _)| &**n).ok_or(EngineError::NoNode(id))?;
let NodeKind::Image(im) = &n.kind else { return Err(bad(C, format!("object {} is not an image", id.0))) };
// Effective resolution, taken at the middle of a distorted image.
let ppi = effective_ppi(vectorcraft_doc::image_quad::nearest_affine(n).unwrap_or(im.xf));
let size = n.geometric_bounds().unwrap_or_default();
// A linked file outside the read roots of the caller asking now is left unnamed, as in Link Info.
let doc_path = super::links::LinkBase::of(st).doc;
@@ -1184,7 +1201,7 @@ pub(crate) fn image_info(s: &mut Session, p: &Value) -> Result<Value> {
"colorMode": st.doc.images.get(&im.key).map_or("RGB", |b| color_mode(&b.bytes)),
"pixelWidth": im.width,
"pixelHeight": im.height,
"ppi": effective_ppi(im.xf),
"ppi": ppi,
"width": size.width(),
"height": size.height(),
}))
+7
View File
@@ -752,6 +752,13 @@ impl Session {
t.set_option("cornerRadius", &r);
}
}
// A press of the tool that is dropped keeps the new radius, also when the tool lent a
// selection tool for the press.
if self.press_taken_by("roundedRectangle")
&& let Some((_, saved)) = self.press_options.as_mut()
{
saved.insert("cornerRadius".into(), r);
}
}
if fonts_folder_changed {
let folder = self.prefs.fonts_folder.trim();
+4
View File
@@ -455,6 +455,10 @@ fn places(map: Affine) -> bool {
/// member).
pub(crate) fn replace_with_image(mut v: Node, image: Node) -> Node {
if !v.is_layer() {
// The new pixels already show a distorted image's distortion.
if let Some(e) = v.extras_if_any() {
e.image_quad = None;
}
return Node { kind: image.kind, appearance: Default::default(), ..v };
}
v.appearance = Default::default();
+24 -10
View File
@@ -130,7 +130,8 @@ type Region = (vectorcraft_geom::BezPath, vectorcraft_geom::FillRule);
#[derive(Clone)]
struct ImageRead<'a> {
blob: &'a vectorcraft_doc::ImageBlob,
xf: vectorcraft_geom::Affine,
/// Pixel space to the page: the image's transform, or a distorted image's projective map.
map: vectorcraft_geom::Homography,
size: (f64, f64),
area: Option<Rect>,
clip: Option<Vec<Region>>,
@@ -261,9 +262,9 @@ impl<'a> Theme<'a> {
let keeps: Vec<Box<dyn Fn(f64, f64) -> bool + '_>> = group
.iter()
.map(|r| {
let (xf, (w, h), area, clip, cost, tested) = (r.xf, r.size, r.area, &r.clip, elements(r), &tested);
let (map, (w, h), area, clip, cost, tested) = (r.map, r.size, r.area, &r.clip, elements(r), &tested);
Box::new(move |u: f64, v: f64| {
let p = xf * Point::new(u * w, v * h);
let Some(p) = map.apply(Point::new(u * w, v * h)) else { return false };
area.is_none_or(|a| a.contains(p))
&& clip.as_ref().is_none_or(|rs| {
tested.set(tested.get().saturating_add(cost));
@@ -278,7 +279,7 @@ impl<'a> Theme<'a> {
.map(|(r, keep)| {
use vectorcraft_geom::kurbo::Shape;
let (w, h) = r.size;
let inv = r.xf.inverse();
let inv = r.map.inverse();
// The box sampled: the marquee, cut to the clipping paths' bounds, so a small
// region a clip shows of a large image is still sampled densely.
let clip_box = r.clip.as_ref().map(|rs| rs.iter().map(|(bp, _)| bp.bounding_box()).reduce(|a, b| a.union(b)).unwrap_or_default());
@@ -286,12 +287,16 @@ impl<'a> Theme<'a> {
(Some(a), Some(c)) => Some(a.intersect(c)),
(a, c) => a.or(c),
};
let box_uv = region.map(|a| {
let uv: Vec<Point> =
[(a.x0, a.y0), (a.x1, a.y0), (a.x0, a.y1), (a.x1, a.y1)].into_iter().map(|(x, y)| inv * Point::new(x, y)).collect();
// A region that crosses a distorted image's horizon has no box: the whole
// image is sampled, and `keep` tests each pixel.
let box_uv = region.zip(inv).and_then(|(a, inv)| {
let uv: Vec<Point> = [(a.x0, a.y0), (a.x1, a.y0), (a.x0, a.y1), (a.x1, a.y1)]
.into_iter()
.map(|(x, y)| inv.apply(Point::new(x, y)))
.collect::<Option<_>>()?;
let low = |f: fn(&Point) -> f64| uv.iter().map(f).fold(f64::INFINITY, f64::min);
let high = |f: fn(&Point) -> f64| uv.iter().map(f).fold(f64::NEG_INFINITY, f64::max);
[low(|p| p.x) / w, low(|p| p.y) / h, high(|p| p.x) / w, high(|p| p.y) / h]
Some([low(|p| p.x) / w, low(|p| p.y) / h, high(|p| p.x) / w, high(|p| p.y) / h])
});
(box_uv, if r.clip.is_some() { clipped } else { budget }, keep.as_ref())
})
@@ -401,7 +406,9 @@ impl<'a> Theme<'a> {
None
};
let size = (f64::from(im.width.max(1)), f64::from(im.height.max(1)));
self.queue_image(ImageRead { blob, xf: im.xf, size, area, clip: self.clip.clone(), colorize });
// A distorted image's pixels are where its projective map puts them.
let map = n.image_map().unwrap_or_else(|| vectorcraft_geom::Homography::from_affine(im.xf));
self.queue_image(ImageRead { blob, map, size, area, clip: self.clip.clone(), colorize });
return;
}
NodeKind::SymbolInstance { symbol, xf } => {
@@ -2051,7 +2058,14 @@ mod tests {
bp.line_to((size, size));
bp.line_to((0.0, size));
bp.close_path();
ImageRead { blob, xf: Affine::IDENTITY, size: (size, size), area: None, clip: Some(vec![(bp, FillRule::NonZero)]), colorize: None }
ImageRead {
blob,
map: vectorcraft_geom::Homography::from_affine(Affine::IDENTITY),
size: (size, size),
area: None,
clip: Some(vec![(bp, FillRule::NonZero)]),
colorize: None,
}
}
/// The reads of one image inside clip groups share the work limit: three reads of a 64 px
+6 -2
View File
@@ -122,7 +122,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Move Type Path Handle",
[],
None,
"{id, subpath?, anchor, which: \"in\"|\"out\", x, y, independent?: bool} move a direction handle of an anchor of type on a path's path to (x, y), as path.setHandle moves a path's (independent: that side only, the anchor becomes a corner); the start and end brackets keep their fractions of the path and the text reflows along it (what Direct Selection does dragging a handle of the path); no undo step when the handle is already there and the path does not change",
"{id, subpath?, anchor, which: \"in\"|\"out\", x, y, independent?: bool, symmetric?: bool} move a direction handle of an anchor of type on a path's path to (x, y), as path.setHandle moves a path's (independent: that side only, the anchor becomes a corner; symmetric: mirror the other handle about the anchor without changing its kind, except at an open end of the path; independent and symmetric cannot both be true; both default false); the start and end brackets keep their fractions of the path and the text reflows along it (what Direct Selection does dragging a handle of the path); no undo step when the handle is already there and the path does not change",
has_doc,
set_path_handle
),
@@ -1449,6 +1449,10 @@ fn set_path_handle(s: &mut Session, p: &Value) -> Result<Value> {
let out = super::object::choice(p, C, "which", &["in", "out"])? != Some("in");
let pos = vectorcraft_geom::Point::new(f64_req(p, "x", C)?, f64_req(p, "y", C)?);
let independent = switch_or(p, "independent", false, C)?;
let symmetric = switch_or(p, "symmetric", false, C)?;
if symmetric && independent {
return Err(bad(C, "`independent` and `symmetric` cannot both be true"));
}
let node = s.doc()?.doc.node(id);
let on_path = matches!(node.map(|n| &n.kind), Some(NodeKind::Text(t)) if matches!(t.kind, vectorcraft_doc::TextKind::OnPath { .. }));
if !on_path || node.is_some_and(|n| n.extras().perspective.is_some()) {
@@ -1461,7 +1465,7 @@ fn set_path_handle(s: &mut Session, p: &Value) -> Result<Value> {
let within = |t: &TextObject| {
t.type_path().and_then(|p| p.bounds()).is_some_and(|b| [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.abs() <= crate::MAX_COORD))
};
if !(t.set_path_handle((si, ai), out, pos, independent) && within(t)) {
if !(t.set_path_handle_with_symmetry((si, ai), out, pos, independent, symmetric) && within(t)) {
t.kind = before;
return Err(bad(C, "no such path anchor, or the path would reach past the canvas"));
}
+124 -1
View File
@@ -21,7 +21,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Free Distort",
[],
None,
"{corners: [[x,y]×4] (TL, TR, BR, BL), from?: [x0,y0,x1,y1] (default: selection bounds), angle?: degrees (counter-clockwise; `from`, or the selection bounds, is then a box in the frame turned by it, as a rotated bounding box is; default 0), ids?} projective warp of anchors and handles; a linked opacity mask's art is warped with its object, an unlinked one stays; each warped object's bounding box (the objects inside groups and the art of linked masks too) turns as the warp turns the art at its center (object.resetBoundingBox squares it again); corners where the box already stands change nothing and add no undo step",
"{corners: [[x,y]×4] (TL, TR, BR, BL), from?: [x0,y0,x1,y1] (default: selection bounds), angle?: degrees (counter-clockwise; `from`, or the selection bounds, is then a box in the frame turned by it, as a rotated bounding box is; default 0), ids?} projective warp of anchors and handles; an image's four corners go exactly where the warp takes them and its pixels are drawn in perspective between them (an error, and nothing changes, when an image's corners would fold over, fall on one line, cross the warp's horizon or lie too close together for a perspective map); a linked opacity mask's art is warped with its object, an unlinked one stays; each warped object's bounding box (the objects inside groups and the art of linked masks too) turns as the warp turns the art at its center (object.resetBoundingBox squares it again); corners where the box already stands change nothing and add no undo step",
has_doc,
distort
),
@@ -86,6 +86,15 @@ impl Projective {
Self { m: [a, b, p0.x, d, e, p0.y, g, h], src, pre: bx.to_doc().inverse() }
}
/// Whether `p` maps in front of the warp's horizon, on the side the box's own corners are.
fn in_front(&self, p: Point) -> bool {
let [.., g, h] = self.m;
let p = self.pre * p;
let u = if self.src.width().abs() > 1e-12 { (p.x - self.src.x0) / self.src.width() } else { 0.0 };
let v = if self.src.height().abs() > 1e-12 { (p.y - self.src.y0) / self.src.height() } else { 0.0 };
g * u + h * v + 1.0 > 1e-9
}
pub fn apply(&self, p: Point) -> Point {
let [a, b, c, d, e, f, g, h] = self.m;
let p = self.pre * p;
@@ -138,6 +147,15 @@ fn warp_node(n: &mut Node, pr: &Projective) -> Option<Rect> {
// A clip group is bounded by its clip path.
NodeKind::Group { children, clip: true } => warp_children(children, pr, |i| i == 0),
NodeKind::Group { children, .. } | NodeKind::Compound { children, .. } => warp_children(children, pr, |i| i >= skip),
// An image's corners follow the warp exactly ([`Node::set_image_corners`]); [`distort`]
// has checked that they stay convex.
NodeKind::Image(_) => {
let b = n.geometric_bounds();
if let Some(q) = n.image_corners() {
let _ = n.set_image_corners(q.map(|p| pr.apply(p)));
}
b
}
_ => {
// No editable points: the affine approximation (which maps the gradients too).
let b = n.geometric_bounds();
@@ -157,6 +175,21 @@ fn warp_node(n: &mut Node, pr: &Projective) -> Option<Rect> {
before
}
/// Whether the warp from `src` to `q` ([`Projective::from_box`]) takes the corners of `src` to `q`,
/// within a millionth of `q`'s shortest side plus the rounding error of coordinates as far from `q`'s
/// first corner as the others. The warp is solved and measured with `src` and `q` moved to the
/// origin, so coordinates far from it do not widen the allowance.
fn reaches_corners(src: OrientedBox, q: [Point; 4]) -> bool {
let origin = q[0].to_vec2();
let q = q.map(|p| p - origin);
let src = OrientedBox { rect: src.rect - src.rect.origin().to_vec2(), ..src };
let pr = Projective::from_box(src, q);
let side = (0..4).map(|i| q[i].distance(q[(i + 1) % 4])).fold(f64::INFINITY, f64::min);
let far = q.iter().map(|p| p.x.abs().max(p.y.abs())).fold(0.0, f64::max);
let tol = side * 1e-6 + far * 1e-12;
side.is_finite() && side > 0.0 && src.corners().iter().zip(q).all(|(c, want)| pr.apply(*c).distance(want) <= tol)
}
/// Warps each of `children` and returns the union of the pre-warp bounds of those `counts` picks
/// by index.
fn warp_children(children: &mut [Arc<Node>], pr: &Projective, counts: impl Fn(usize) -> bool) -> Option<Rect> {
@@ -166,6 +199,76 @@ fn warp_children(children: &mut [Arc<Node>], pr: &Projective, counts: impl Fn(us
})
}
/// The first image in `n` (its children and the art of linked opacity masks, as [`warp_node`]
/// reaches them) whose corners `pr` would fold, collapse or carry past the warp's horizon, with
/// why.
fn unwarpable_image(n: &Node, pr: &Projective) -> Option<(vectorcraft_doc::NodeId, Unwarpable)> {
if let (Some(q), NodeKind::Image(im)) = (n.image_corners(), &n.kind) {
if !q.iter().all(|p| pr.in_front(*p)) {
return Some((n.id, Unwarpable::Horizon));
}
if let Err(e) = vectorcraft_doc::image_quad::check_for(im, &q.map(|p| pr.apply(p))) {
return Some((
n.id,
match e {
vectorcraft_doc::image_quad::QuadError::NotFinite | vectorcraft_doc::image_quad::QuadError::NotConvex => Unwarpable::NotConvex,
vectorcraft_doc::image_quad::QuadError::TooNarrow => Unwarpable::TooNarrow,
},
));
}
}
warped_parts(n).into_iter().find_map(|c| unwarpable_image(c, pr))
}
/// The first image in `n` that [`warp_node`] reaches (its children and the art of linked opacity
/// masks).
fn first_image(n: &Node) -> Option<vectorcraft_doc::NodeId> {
if matches!(n.kind, NodeKind::Image(_)) {
return Some(n.id);
}
warped_parts(n).into_iter().find_map(first_image)
}
/// The objects inside `n` that [`warp_node`] warps point by point: the children of layers, groups
/// and compound paths, and the art of a linked opacity mask on those, paths and images. Other
/// objects (blends, envelopes, repeats and the rest) take the warp's affine approximation whole.
fn warped_parts(n: &Node) -> Vec<&Node> {
let inside = matches!(n.kind, NodeKind::Layer { .. } | NodeKind::Group { .. } | NodeKind::Compound { .. });
let mask_too = inside || matches!(n.kind, NodeKind::Path { .. } | NodeKind::Image(_));
let children = n.children().filter(|_| inside).into_iter().flatten().map(|c| &**c);
let mask = n.extras().mask.as_deref().filter(|m| mask_too && m.linked).map(|m| &*m.art);
children.chain(mask).collect()
}
/// The error of `command` on image `id`, which is distorted (Perspective Distort or Free Distort)
/// in a way the command cannot keep.
pub(crate) fn distorted_image_error(command: &str, id: vectorcraft_doc::NodeId) -> EngineError {
bad(command, format!("object {} is an image changed by Perspective Distort or Free Distort, which this command does not work on", id.0))
}
/// Why an image cannot follow the corners of a distort.
#[derive(Clone, Copy)]
enum Unwarpable {
/// Its corners would fold over, meet or fall on one line.
NotConvex,
/// A corner would cross the warp's horizon.
Horizon,
/// Its corners would be too close together for a perspective map to place them.
TooNarrow,
}
/// The error of `object.distort` when image `id` cannot follow its corners.
fn unwarpable_error(id: vectorcraft_doc::NodeId, why: Unwarpable) -> EngineError {
const C: &str = "object.distort";
match why {
Unwarpable::NotConvex => bad(C, format!("image {} cannot be distorted this way: its corners would not make a convex shape", id.0)),
Unwarpable::Horizon => bad(C, format!("image {} cannot be distorted this way: its corners would cross the warp's horizon", id.0)),
Unwarpable::TooNarrow => {
bad(C, format!("image {} cannot be distorted this way: its corners would be too close together for a perspective map", id.0))
}
}
}
fn distort(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "object.distort";
// All four corners or nothing, each exactly [x, y]: nothing malformed is left out.
@@ -208,6 +311,26 @@ fn distort(s: &mut Session, p: &Value) -> Result<Value> {
return Ok(ids_json);
}
let pr = Projective::from_box(src, [tl, tr, br, bl]);
// An image's corners follow the handles exactly, so they must stay a convex shape: nothing
// changes when one would not.
let doc = &s.doc()?.doc;
// Corners that do not make a convex shape give no perspective map (the warp falls back to an
// affine one), so an image cannot follow them.
if vectorcraft_doc::image_quad::check(&[tl, tr, br, bl]).is_err()
&& let Some(id) = ids.iter().filter_map(|id| doc.node(*id)).find_map(first_image)
{
return Err(unwarpable_error(id, Unwarpable::NotConvex));
}
// Corners so close together that the map falls back to an affine one: the box's corners do
// not reach the handles, so an image cannot follow them either.
if !reaches_corners(src, [tl, tr, br, bl])
&& let Some(id) = ids.iter().filter_map(|id| doc.node(*id)).find_map(first_image)
{
return Err(unwarpable_error(id, Unwarpable::TooNarrow));
}
if let Some((id, why)) = ids.iter().filter_map(|id| doc.node(*id)).find_map(|n| unwarpable_image(n, &pr)) {
return Err(unwarpable_error(id, why));
}
s.edit("Free Distort", |d, _| {
for id in &ids {
if let Some(n) = d.node_mut(*id) {
+3
View File
@@ -329,6 +329,9 @@ pub struct Session {
/// The id and persistent options of the tool when the press under way began, which a dropped
/// press puts back ([`Session::drop_tool_press`]).
pub(crate) press_options: Option<(String, serde_json::Map<String, serde_json::Value>)>,
/// An option of the active tool was set during the press under way, which stored all of its
/// options, so a dropped press stores the options it puts back.
pub(crate) press_options_stored: bool,
/// The engine saves the selection and active layer before a Type press and restores them if it drops.
pub(crate) press_type_selection: Option<(Selection, Option<NodeId>)>,
/// The freeform gradient point selected once the tool took the press under way, which a
+1
View File
@@ -137,6 +137,7 @@ impl Session {
plane_widget_press: false,
pointer_held: false,
press_options: None,
press_options_stored: false,
press_type_selection: None,
press_point: None,
ruler_guide: None,
+1
View File
@@ -202,6 +202,7 @@ mod symbol_nine_slice;
mod symbolbounds;
mod symboledit;
mod symbolism_options;
mod symbolism_shift;
mod symbollib;
mod tangent_line;
mod targeting;
+62
View File
@@ -123,6 +123,7 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
"engraving",
"arrows",
"image-brush",
"artistic",
"vector-packs"
]
);
@@ -181,6 +182,7 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
("dry-media", "art"),
("arrows", "art"),
("image-brush", "scatter"),
("artistic", "art"),
("vector-packs", "scatter"),
] {
let (_, lib) = cmd::brushlib::library(&s, id).unwrap();
@@ -212,6 +214,46 @@ fn the_builtin_libraries_are_original_brushes_generated_in_code() {
assert!(s.execute("brush.library", &json!({"library": "nope"})).is_err());
}
#[test]
fn artistic_library_strokes_are_editable_and_reopen_from_a_saved_library() {
let mut s = session();
let (_, lib) = cmd::brushlib::library(&s, "artistic").unwrap();
let (_, alias) = cmd::brushlib::library(&s, "Artistic").unwrap();
assert_eq!(alias.brushes, lib.brushes);
assert_eq!(run(&mut s, "brush.library", json!({"library": "Artistic"}))["id"], "artistic");
let names = ["Orbit Lines", "Petal Garland", "Lattice Braid", "Facet Sweep"];
assert_eq!(lib.brushes.iter().map(|b| b.name.as_str()).collect::<Vec<_>>(), names);
let line = run(&mut s, "shape.line", json!({"x1": 10, "y1": 50, "x2": 190, "y2": 50}))["id"].as_u64().unwrap();
let red = vectorcraft_doc::StrokeLayer::new(vectorcraft_color::Paint::solid(vectorcraft_color::Color::rgb(1.0, 0.0, 0.0)), 1.0);
for b in &lib.brushes {
let BrushKind::Art(a) = &b.kind else { panic!("{} is not an art brush", b.name) };
assert!(art_paths(&a.art).len() >= 2, "{} has no editable vector art", b.name);
for path in [line_to(180.0), line_to(1.0)] {
assert!(!vectorcraft_brush::stroke_pieces(&lib.doc, b, &path, &black_stroke()).is_empty(), "{} draws nothing", b.name);
}
// The art is black, so with Tints every path takes the stroke color itself.
let mut fills = vec![];
for piece in vectorcraft_brush::stroke_pieces(&lib.doc, b, &line_to(180.0), &red) {
piece.walk(&mut |n| {
if n.path_data().is_some() {
fills.push(n.appearance.fill_paint().color().map(|c| c.to_rgb()));
}
});
}
let is_red = |c: &Option<[f32; 3]>| c.is_some_and(|[r, g, b]| (r - 1.0).abs() < 1e-5 && g.abs() < 1e-5 && b.abs() < 1e-5);
assert!(!fills.is_empty() && fills.iter().all(is_red), "{} does not take the stroke color: {fills:?}", b.name);
let before = undo_len(&s);
let added = run(&mut s, "brush.addFromLibrary", json!({"library": "artistic", "name": b.name, "apply": true, "ids": [line]}));
assert_eq!(strs(&added["added"]), [b.name.as_str()]);
assert_eq!(added["applied"], json!([line]));
assert_eq!(undo_len(&s), before + 1);
}
let saved = run(&mut s, "brush.saveLibrary", json!({"names": names}));
let bytes = vectorcraft_format::base64_decode(saved["dataBase64"].as_str().unwrap()).unwrap();
let reopened = vectorcraft_format::load(&bytes).unwrap();
assert_eq!(vectorcraft_brush::library(&reopened), lib.brushes);
}
#[test]
fn vector_packs_marks_are_editable_and_survive_a_saved_library() {
let mut s = session();
@@ -291,6 +333,26 @@ fn image_brush_stamps_draw_and_carry_their_pixels_when_added_and_saved() {
assert_eq!(reopened.images, lib.doc.images);
}
#[test]
fn a_loaded_library_named_artistic_keeps_its_name_ahead_of_the_builtin_alias() {
let mut file = vectorcraft_doc::Document::new(100.0, 100.0);
vectorcraft_brush::store(&mut file, &[vectorcraft_brush::defaults()[0].clone()]);
let b64 = vectorcraft_format::base64_encode(&vectorcraft_format::save_file(&file));
let mut s = session();
let loaded = run(&mut s, "brush.loadLibrary", json!({"dataBase64": b64, "name": "Artistic.vectorcraft"}));
assert_eq!(loaded["name"], "Artistic");
let id = loaded["library"].as_str().unwrap();
assert_eq!(run(&mut s, "brush.library", json!({"library": "Artistic"}))["id"], id);
assert_eq!(run(&mut s, "brush.library", json!({"library": "ARTISTIC"}))["id"], id);
assert_eq!(run(&mut s, "brush.library", json!({"library": "artistic"}))["id"], "artistic", "exact built-in id still works");
// A name a built-in library has selects the built-in, as for every built-in; the loaded one keeps its id.
let full = run(&mut s, "brush.loadLibrary", json!({"dataBase64": b64, "name": "Artistic Brushes.vectorcraft"}));
assert_eq!(full["name"], "Artistic Brushes");
let full_id = full["library"].as_str().unwrap();
assert_eq!(run(&mut s, "brush.library", json!({"library": "Artistic Brushes"}))["id"], "artistic");
assert_eq!(run(&mut s, "brush.library", json!({"library": full_id}))["id"], full_id);
}
/// Every path of brush art `n`: (anchors, opacity).
fn art_paths(n: &vectorcraft_doc::Node) -> Vec<(usize, f32)> {
let mut out = vec![];
+4 -1
View File
@@ -9491,9 +9491,12 @@ fn image_trace_split_view_keeps_and_validates_its_divider() {
assert_eq!((back.node(g).unwrap().trace_view(), back.node(g).unwrap().trace_split()), (vectorcraft_doc::TraceView::Split, 0.25));
// Bad dividers are refused and change nothing.
let steps = s.doc().unwrap().history.undo.len();
for bad in [json!(-0.1), json!(1.01), json!("0.5"), json!(true), json!([0.5])] {
for bad in [json!(-0.1), json!(1.01), json!("0.5"), json!(true), json!([0.5]), json!(null)] {
assert!(s.execute("imageTrace.setView", &json!({"view": "split", "split": bad})).is_err(), "{bad}");
}
// A null divider with another view is refused too, and the view stays.
assert!(s.execute("imageTrace.setView", &json!({"view": "outlines", "split": null})).is_err());
assert_eq!(node(&s, g).trace_view(), vectorcraft_doc::TraceView::Split);
assert_eq!((s.doc().unwrap().history.undo.len(), node(&s, g).trace_split()), (steps, 0.25));
for edge in [0.0, 1.0] {
s.execute("imageTrace.setView", &json!({"view": "split", "split": edge})).unwrap();
+39
View File
@@ -318,6 +318,45 @@ fn convert_query_and_intents() {
assert!(s.execute("color.convert", &json!({"color": "#808080", "intent": "vivid"})).is_err());
}
/// `to: "oklch"` answers the OKLCH of the color's display sRGB, which converts back to the color;
/// a CMYK color's display color, not its naive separation, sets them.
#[test]
fn convert_to_oklch_answers_lightness_chroma_and_hue() {
let _g = GLOBAL.lock().unwrap_or_else(|e| e.into_inner());
let mut s = session();
let r = s.execute("color.convert", &json!({"color": "#ff0000", "to": "oklch"})).unwrap();
assert_eq!(r["model"], "oklch");
let v: Vec<f64> = r["values"].as_array().unwrap().iter().map(|v| v.as_f64().unwrap()).collect();
assert!((v[0] - 62.80).abs() < 0.005 && (v[1] - 0.2577).abs() < 5e-5 && (v[2] - 29.23).abs() < 0.005, "{r}");
let (rgb, lowered) = vectorcraft_color::oklab::from_oklch(v[0] / 100.0, v[1], v[2]);
assert!(!lowered);
assert_eq!(Color::rgb(rgb[0], rgb[1], rgb[2]).to_hex(), "#ff0000");
assert_eq!(r["hex"], "#ff0000");
let gray = s.execute("color.convert", &json!({"color": "#808080", "to": "oklch"})).unwrap();
assert_eq!(gray["values"][2], 0.0, "{gray}");
let ink = json!({"c": 1.0, "m": 0.0, "y": 0.0, "k": 0.0});
let cyan = s.execute("color.convert", &json!({"color": ink, "to": "oklch"})).unwrap();
let shown = vectorcraft_color::oklab::to_oklch(cms::active().display_rgb(&Color::cmyk(1.0, 0.0, 0.0, 0.0)));
let naive = vectorcraft_color::oklab::to_oklch([0.0, 1.0, 1.0]);
let c: Vec<f64> = cyan["values"].as_array().unwrap().iter().map(|v| v.as_f64().unwrap()).collect();
let got = [c[0] / 100.0, c[1], c[2]];
assert!((0..3).all(|i| (got[i] - shown[i]).abs() < 1e-9) && shown[1] > 0.05, "{cyan} {shown:?}");
assert!((got[0] - naive[0]).abs() > 0.02, "{cyan} {naive:?}");
// A Lab color outside sRGB answers the OKLCH of its color clipped to sRGB.
let vivid = s.execute("color.convert", &json!({"color": {"l": 50.0, "a": 100.0, "b": 0.0}, "to": "oklch"})).unwrap();
let w: Vec<f64> = vivid["values"].as_array().unwrap().iter().map(|v| v.as_f64().unwrap()).collect();
let shown = cms::active().display_rgb(&Color::lab(50.0, 100.0, 0.0)).map(|v| v.clamp(0.0, 1.0));
let clipped = vectorcraft_color::oklab::to_oklch(shown);
assert!((w[0] / 100.0 - clipped[0]).abs() < 1e-9 && (w[1] - clipped[1]).abs() < 1e-9, "{vivid} {clipped:?}");
assert!((w[2] - clipped[2]).abs() < 1e-9 && (0.0..360.0).contains(&w[2]), "{vivid} {clipped:?}");
assert!(vectorcraft_color::oklab::in_srgb(vectorcraft_color::oklab::oklch_to_srgb(w[0] / 100.0, w[1], w[2])), "{vivid}");
// RGB numbers past 0..1 answer the OKLCH of the clipped color `hex` reports: white.
let past = s.execute("color.convert", &json!({"color": [2.0, 2.0, 2.0], "to": "oklch"})).unwrap();
assert_eq!(past["hex"], "#ffffff");
let l = past["values"][0].as_f64().unwrap();
assert!((l - 100.0).abs() < 0.01 && past["values"][1].as_f64().unwrap() < 1e-3, "{past}");
}
#[test]
fn assign_profile_is_stored_and_undoable() {
let _g = GLOBAL.lock().unwrap_or_else(|e| e.into_inner());
+21
View File
@@ -1002,6 +1002,27 @@ fn dcs_transparency_counts_a_transparent_dcs_image_over_another() {
assert!(marked(b), "the opaque image it overlaps");
}
/// Replace measures a DCS file's clipping group by its bounds, not by its plates' image, so a
/// distorted plate image does not stop an image replacing the group.
#[test]
fn replace_is_not_refused_for_a_dcs_group_whose_image_is_distorted() {
let dir = temp_dir("replace-distorted");
let path = write(&dir, "pic.eps", &two_plates());
let mut s = session();
let r = s.execute("file.place", &json!({ "path": path, "at": [100, 100] })).unwrap();
let group = r["ids"][0].clone();
let image = image_of(&s, &group).id;
let b = s.doc().unwrap().doc.node(image).unwrap().geometric_bounds().unwrap();
let (x0, y0, x1, y1) = (b.x0, b.y0, b.x1, b.y1);
let corners = json!([[x0 + 4.0, y0], [x1 - 4.0, y0], [x1, y1], [x0, y1]]);
s.execute("object.distort", &json!({ "ids": [image.0], "corners": corners })).unwrap();
assert!(s.doc().unwrap().doc.node(image).unwrap().is_distorted_image());
s.execute("select.set", &json!({ "ids": [group] })).unwrap();
let png = crate::tests_links::png(2, 2, [0, 0, 255]);
let out = s.execute("file.place", &json!({"replace": true, "name": "b.png", "dataBase64": vectorcraft_format::base64_encode(&png)}));
assert!(out.is_ok(), "{out:?}");
}
#[test]
fn dcs_transparency_counts_characters_with_a_transparent_gradient() {
use vectorcraft_color::{Gradient, GradientKind, GradientPaint, GradientStop};
+75
View File
@@ -588,6 +588,81 @@ fn a_symbols_link_without_a_relative_path_follows_the_moved_file() {
assert_eq!(paths, [moved.clone(), moved], "the layers' link, then the symbol's");
}
/// Update Links gives a distorted image its file's new pixels between the same corners: its
/// Placement Options' fill and clip do not move or clip it. Its transform takes the new pixel size,
/// and Link Info measures its scale at its middle.
#[test]
fn update_links_keeps_a_distorted_images_corners() {
let dir = Folder::new("distorted-update");
let photo = dir.file("photo.png");
write(&photo, &png(20, 10, RED));
let mut s = session();
let id = place(&mut s, &photo);
s.execute("links.placementOptions", &json!({"ids": [id.0], "preserve": "fill", "clip": true})).unwrap();
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
s.execute("object.distort", &json!({"corners": [[240, 300], [260, 300], [300, 400], [200, 400]]})).unwrap();
let corners = |s: &Session| s.doc().unwrap().doc.node(id).unwrap().image_corners().unwrap();
let before = corners(&s);
assert!(s.doc().unwrap().doc.node(id).unwrap().is_distorted_image());
// The far corner of the pixels as the transform alone places them.
let far = |s: &Session| {
let NodeKind::Image(im) = &s.doc().unwrap().doc.node(id).unwrap().kind else { panic!("an image") };
im.xf * vectorcraft_geom::Point::new(f64::from(im.width), f64::from(im.height))
};
let far_before = far(&s);
// Link Info measures the scale where the effective resolution is measured: at the middle.
let scale_matches_ppi = |s: &mut Session| {
let info = s.execute("links.info", &json!({"id": id.0})).unwrap();
for i in 0..2 {
let (scale, ppi, eff) = (info["scale"][i].as_f64().unwrap(), info["ppi"][i].as_f64().unwrap(), info["effectivePpi"][i].as_f64().unwrap());
assert!((scale - ppi / eff * 100.0).abs() < 1e-6, "{info}");
}
};
scale_matches_ppi(&mut s);
// A copy in a symbol, distorted the same way, shows the same file.
let copy = place(&mut s, &photo);
s.execute("links.placementOptions", &json!({"ids": [copy.0], "preserve": "fill", "clip": true})).unwrap();
s.execute("select.set", &json!({"ids": [copy.0]})).unwrap();
s.execute("object.distort", &json!({"corners": [[240, 300], [260, 300], [300, 400], [200, 400]]})).unwrap();
s.execute("symbol.new", &json!({"name": "Mark", "ids": [copy.0]})).unwrap();
let in_symbol = |s: &Session| {
let mut out = vec![];
s.doc().unwrap().doc.symbols[0].art.walk(&mut |n| {
if let NodeKind::Image(im) = &n.kind {
out.push((n.is_distorted_image(), (im.width, im.height)));
}
});
out
};
let symbol_corners = |s: &Session| {
let mut out = vec![];
s.doc().unwrap().doc.symbols[0].art.walk(&mut |n| out.extend(n.image_corners()));
out
};
assert_eq!(in_symbol(&s), [(true, (20, 10))]);
let symbol_before = symbol_corners(&s);
assert_eq!(symbol_before.len(), 1);
write(&photo, &png(60, 20, BLUE));
let u = s.execute("links.update", &json!({})).unwrap();
assert_eq!(u["updated"].as_array().unwrap().len(), 2, "{u}");
let d = &s.doc().unwrap().doc;
let n = d.node(id).unwrap();
assert!(n.is_distorted_image());
assert_eq!(corners(&s), before);
let NodeKind::Image(im) = &n.kind else { panic!("an image") };
assert_eq!((im.width, im.height), (60, 20));
// The transform takes the new pixel size, so a placement by the transform keeps the old size.
assert!(far(&s).distance(far_before) < 1e-9, "{:?} vs {far_before:?}", far(&s));
let d = &s.doc().unwrap().doc;
assert!(!matches!(d.parent_of(id).and_then(|p| d.node(p)).map(|p| &p.kind), Some(NodeKind::Group { clip: true, .. })), "not clipped");
let mut clipped = false;
d.symbols[0].art.walk(&mut |n| clipped |= matches!(n.kind, NodeKind::Group { clip: true, .. }));
assert!(!clipped, "the symbol's image is not clipped");
assert_eq!(in_symbol(&s), [(true, (60, 20))]);
assert_eq!(symbol_corners(&s), symbol_before, "the symbol's image keeps its corners");
scale_matches_ppi(&mut s);
}
/// Update Links reads a changed file again for the images inside symbols, patterns and opacity
/// masks too: those showing the same content as an image in the layers, and those no object in the
/// layers shows. Each takes the file's place as its own Placement Options say, in one undo step,
+160
View File
@@ -1907,6 +1907,166 @@ fn pathfinder_journal_entries_replay_with_the_options_they_used() {
assert!(s.execute("object.pathfinder.divide", &json!({"precision": 20})).is_err());
}
/// The leaf objects of `n`, in paint order.
fn leaves_of(n: &vectorcraft_doc::Node, out: &mut Vec<vectorcraft_doc::Node>) {
match n.children() {
Some(children) => children.iter().for_each(|c| leaves_of(c, out)),
None => out.push(n.clone()),
}
}
/// Apply the live Pathfinder effect `effect` with `params` to the selection, then expand its
/// appearance: the objects it draws.
fn live_pieces(s: &mut Session, effect: &str, params: Value) -> Vec<vectorcraft_doc::Node> {
let g = ids(&s.execute("effect.apply", &json!({"effect": effect, "params": params})).unwrap())[0];
s.execute("effect.expandAppearance", &json!({"ids": [g.0]})).unwrap();
let mut out = vec![];
leaves_of(&node(s, g), &mut out);
out
}
/// The parameters of the first effect of the selected object.
fn first_effect_params(s: &Session) -> Value {
let st = s.doc().unwrap();
st.doc.node(st.selection.objects[0]).unwrap().appearance.effects[0].params.clone()
}
/// A Pathfinder effect keeps the Pathfinder Options in force when it is applied, those its params
/// give aside, and its journal entry carries them.
#[test]
fn a_pathfinder_effect_keeps_the_options_in_force_when_applied() {
let mut s = session();
let (a, b) = (rect(&mut s, 0.0, 0.0, 100.0, 100.0), rect(&mut s, 50.0, 50.0, 100.0, 100.0));
s.execute("object.pathfinder.options", &json!({"precision": 1, "removeRedundantPoints": true, "removeUnpainted": true})).unwrap();
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
s.execute("effect.apply", &json!({"effect": "pathfinder.divide"})).unwrap();
let all = json!({"precision": 1.0, "removeRedundantPoints": true, "removeUnpainted": true});
assert_eq!(first_effect_params(&s), all);
assert_eq!(s.journal.last().unwrap().1["params"], all, "the journal entry gives the options it used");
s.execute("effect.apply", &json!({"effect": "pathfinder.softMix", "params": {"precision": 0.5}})).unwrap();
let st = s.doc().unwrap();
let mix = &st.doc.node(st.selection.objects[0]).unwrap().appearance.effects[1].params;
assert_eq!(mix, &json!({"mixingRate": 50.0, "precision": 0.5, "removeRedundantPoints": true, "removeUnpainted": true}));
}
/// A live Pathfinder effect evaluates with its own options as the panel's operations do with
/// Pathfinder Options: a precision of 1 pt drops a 0.5 pt overlap, Divide leaves out an unfilled
/// object's pieces, and Remove Redundant Points drops an anchor that shapes nothing.
#[test]
fn a_pathfinder_effect_evaluates_with_its_own_options() {
for (precision, faces) in [(0.01, 3), (1.0, 2)] {
let mut s = session();
let a = rect(&mut s, 0.0, 0.0, 100.0, 100.0);
let b = rect(&mut s, 0.0, 99.5, 100.0, 100.0);
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
assert_eq!(live_pieces(&mut s, "pathfinder.divide", json!({"precision": precision})).len(), faces, "precision {precision}");
}
for on in [false, true] {
let mut s = session();
filled_and_unfilled(&mut s);
let divided = live_pieces(&mut s, "pathfinder.divide", json!({"removeUnpainted": on}));
let unfilled = divided.iter().filter(|n| n.appearance.fill_paint().is_none()).count();
assert_eq!((unfilled, divided.len() - unfilled), (if on { 0 } else { 2 }, 1), "removeUnpainted {on}");
}
for on in [false, true] {
let mut s = session();
let pts = [(0.0, 0.0), (50.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)];
let anchors: Vec<Value> = pts.iter().map(|(x, y)| json!({"x": x, "y": y})).collect();
let a = NodeId(s.execute("path.create", &json!({"anchors": anchors, "closed": true})).unwrap()["id"].as_u64().unwrap());
let b = rect(&mut s, 20.0, 20.0, 60.0, 60.0);
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
let united = live_pieces(&mut s, "pathfinder.add", json!({"removeRedundantPoints": on}));
let count = united[0].path_data().unwrap().anchor_count();
assert!(if on { count == 4 } else { count > 4 }, "removeRedundantPoints {on}: {count} anchors");
}
}
/// An effect saved before Pathfinder effects kept their own options draws as one given their
/// defaults, so older documents look as they did.
#[test]
fn a_pathfinder_effect_saved_without_options_draws_as_before() {
let draw = |params: Value| {
let mut s = session();
filled_and_unfilled(&mut s);
let g = ids(&s.execute("effect.apply", &json!({"effect": "pathfinder.divide"})).unwrap())[0];
s.edit("t", |d, _| {
d.node_mut(g).unwrap().appearance.effects[0].params = params;
Ok(())
})
.unwrap();
s.execute("effect.expandAppearance", &json!({"ids": [g.0]})).unwrap();
serde_json::to_value(node(&s, g)).unwrap()
};
assert_eq!(draw(json!({})), draw(json!({"precision": 0.01, "removeRedundantPoints": false, "removeUnpainted": false})));
}
/// `effect.setParams` edits a Pathfinder effect's options as one undo step, records none for the
/// values it already evaluates with, and refuses values out of range or of the wrong type.
#[test]
fn pathfinder_effect_options_edit_as_one_step_and_refuse_bad_values() {
let mut s = session();
let (a, b) = (rect(&mut s, 0.0, 0.0, 100.0, 100.0), rect(&mut s, 50.0, 50.0, 100.0, 100.0));
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
s.execute("effect.apply", &json!({"effect": "pathfinder.add"})).unwrap();
let steps = |s: &Session| s.doc().unwrap().history.undo.len();
let doc = |s: &Session| serde_json::to_value(&*s.doc().unwrap().doc).unwrap();
let before = steps(&s);
let same = s.execute("effect.setParams", &json!({"index": 0, "params": {"precision": 0.01, "removeUnpainted": false}})).unwrap();
assert_eq!((same, steps(&s)), (json!({"ids": []}), before), "the values it has: no step");
// An effect saved without options evaluates with the defaults: given them, it is unchanged.
let g = s.doc().unwrap().selection.objects[0];
s.edit("t", |d, _| {
d.node_mut(g).unwrap().appearance.effects[0].params = json!({});
Ok(())
})
.unwrap();
let before = steps(&s);
let defaults = json!({"index": 0, "params": {"precision": 0.01, "removeRedundantPoints": false, "removeUnpainted": false}});
assert_eq!(s.execute("effect.setParams", &defaults).unwrap(), json!({"ids": []}));
assert_eq!(steps(&s), before);
s.execute("effect.setParams", &json!({"index": 0, "params": {"precision": 2, "removeRedundantPoints": true}})).unwrap();
assert_eq!(steps(&s), before + 1, "one step");
assert_eq!(first_effect_params(&s), json!({"precision": 2, "removeRedundantPoints": true}));
let kept = doc(&s);
for bad in [
json!({"precision": 0}),
json!({"precision": 11}),
json!({"precision": "1 pt"}),
json!({"precision": null}),
json!({"removeRedundantPoints": "yes"}),
json!({"removeUnpainted": 1}),
] {
assert!(s.execute("effect.setParams", &json!({"index": 0, "params": bad})).is_err(), "setParams {bad}");
assert!(s.execute("effect.apply", &json!({"effect": "pathfinder.trim", "params": bad})).is_err(), "apply {bad}");
assert_eq!(doc(&s), kept, "{bad} changes nothing");
}
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(first_effect_params(&s), json!({}), "undo restores the options");
}
/// A precision that Scale Strokes & Effects took past the range evaluates at its bound, and setting
/// the bound is still an edit: a later scale then starts from the value set.
#[test]
fn a_precision_set_after_a_scale_past_its_range_is_kept() {
let mut s = session();
let (a, b) = (rect(&mut s, 0.0, 0.0, 100.0, 100.0), rect(&mut s, 50.0, 50.0, 100.0, 100.0));
s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
s.execute("effect.apply", &json!({"effect": "pathfinder.add", "params": {"precision": 8}})).unwrap();
let precision = |s: &Session| first_effect_params(s)["precision"].as_f64();
s.execute("object.scale", &json!({"sx": 200, "strokes": true})).unwrap();
assert_eq!(precision(&s), Some(16.0));
let steps = s.doc().unwrap().history.undo.len();
let out = s.execute("effect.setParams", &json!({"index": 0, "params": {"precision": 10}})).unwrap();
assert_ne!(out, json!({"ids": []}), "an edit");
assert_eq!((precision(&s), s.doc().unwrap().history.undo.len()), (Some(10.0), steps + 1));
s.execute("object.scale", &json!({"sx": 50, "strokes": true})).unwrap();
assert_eq!(precision(&s), Some(5.0));
// The value it stores is still no edit.
let steps = s.doc().unwrap().history.undo.len();
assert_eq!(s.execute("effect.setParams", &json!({"index": 0, "params": {"precision": 5}})).unwrap(), json!({"ids": []}));
assert_eq!(s.doc().unwrap().history.undo.len(), steps);
}
/// A single group containing multiple overlapping paths is accepted by Crop.
#[test]
fn crop_operates_on_a_single_selected_group_of_paths() {
+20
View File
@@ -1422,6 +1422,26 @@ fn theme_picker_marquee_takes_the_area_and_picks_add_up() {
assert_eq!(got, ["rgb 0 255 0", "rgb 255 255 0"]);
}
/// A distorted image is read where its pixels are drawn, between its corners.
#[test]
fn theme_picker_reads_a_distorted_image_where_it_is_drawn() {
let mut s = session();
let (id, b) = halves_image(&mut s, 64, 32, [255, 0, 0, 255], [0, 0, 255, 255]);
let (x, y0, y1) = (b.x1 + 20.0, b.y0, b.y1);
run(&mut s, "select.set", json!({"ids": [id.0]}));
run(&mut s, "object.distort", json!({"corners": [[x + 40.0, y0], [x + 60.0, y0], [x + 100.0, y1], [x, y1]]}));
// The lower left of the trapezoid, outside the rectangle the image was placed in: red.
assert_eq!(pick_theme(&mut s, json!({"picks": [{"rect": [x + 2.0, y1 - 4.0, x + 20.0, y1 - 1.0]}]})), ["rgb 255 0 0"]);
// Where the image was: nothing.
assert!(pick_theme(&mut s, json!({"picks": [{"rect": [b.x0 + 1.0, b.y0 + 1.0, b.x1 - 1.0, b.y1 - 1.0]}]})).is_empty());
// A marquee reaching past the horizon its sides meet at (a quarter of its height above its
// top) still reads every pixel it covers.
let h = y1 - y0;
let mut both = pick_theme(&mut s, json!({"picks": [{"rect": [x - 10.0, y0 - h, x + 110.0, y1 + 1.0]}]}));
both.sort();
assert_eq!(both, ["rgb 0 0 255", "rgb 255 0 0"]);
}
/// Pixels less than half opaque are left out, and so is an image whose pixels can't be read.
#[test]
fn theme_picker_leaves_out_clear_pixels_and_unreadable_images() {
@@ -180,6 +180,48 @@ fn average_at_the_mean_adds_no_undo_step() {
assert!(state(&s) == before);
}
/// An instance the brush reaches but leaves as it is (the Symbol Screener with Alt on an opaque
/// instance, or without Alt on one at the lowest opacity it gives) is not counted, and a stroke
/// that changes no instance adds no undo step.
#[test]
fn an_instance_left_as_it_is_is_not_counted() {
let mut s = session();
let (opaque, faint) = (dot(&mut s, 100.0, 150.0), dot(&mut s, 300.0, 150.0));
s.execute("transparency.set", &json!({"ids": [faint.0], "opacity": 5})).unwrap();
let before = state(&s);
let r = adjust(&mut s, json!({"tool": "screen", "points": [[100, 150]], "radius": 30, "intensity": 10, "alt": true}));
assert_eq!(r["count"], 0, "Alt on an opaque instance");
let r = adjust(&mut s, json!({"tool": "screen", "points": [[300, 150]], "radius": 30, "intensity": 10}));
assert_eq!(r["count"], 0, "an instance at 5%");
assert!(state(&s) == before, "a stroke that changes nothing changed the document or its history");
// A stroke over both counts only the instance it changes.
let r = adjust(&mut s, json!({"tool": "screen", "points": [[200, 150]], "radius": 150, "intensity": 10}));
assert_eq!(r["count"], 1);
assert!(node(&s, opaque).opacity < 1.0 && node(&s, faint).opacity == 0.05);
}
/// Average gives an opacity below 5% when that is the mean: the Symbol Sprayer's new instance and
/// the Symbol Screener's instances take the mean of the instances under the brush.
#[test]
fn average_keeps_a_mean_opacity_below_five_percent() {
let mut s = session();
let set = NodeId(s.execute("symbol.spray", &json!({"name": "Dot", "points": [[200, 150]], "radius": 4})).unwrap()["id"].as_u64().unwrap());
let first = members(&s, set)[0];
s.execute("transparency.set", &json!({"ids": [first.0], "opacity": 2})).unwrap();
s.select(|_, sel| sel.set([set])).unwrap();
s.execute("symbol.spray", &json!({"name": "Dot", "points": [[215, 150]], "radius": 30})).unwrap();
let sprayed = *members(&s, set).last().unwrap();
assert!((node(&s, sprayed).opacity - 0.02).abs() < 1e-6, "{}", node(&s, sprayed).opacity);
// Two instances at 0% and 4%: Average brings both toward 2%, and neither goes past it.
let mut s = session();
let (a, b) = (dot(&mut s, 200.0, 150.0), dot(&mut s, 220.0, 150.0));
s.execute("transparency.set", &json!({"ids": [a.0], "opacity": 0})).unwrap();
s.execute("transparency.set", &json!({"ids": [b.0], "opacity": 4})).unwrap();
adjust(&mut s, json!({"tool": "screen", "points": [[210, 150]], "radius": 40, "intensity": 10, "method": "average"}));
let (pa, pb) = (node(&s, a).opacity, node(&s, b).opacity);
assert!(pa > 0.0 && pa <= 0.02 + 1e-6 && (0.02 - 1e-6..0.04).contains(&pb), "{pa} {pb}");
}
/// Average evens out the Symbol Stainer's amount and the Symbol Scruncher's spacing.
#[test]
fn average_evens_out_the_stain_and_the_spacing() {
@@ -279,6 +321,38 @@ fn an_unknown_method_is_refused() {
assert_eq!(center(&s, a), Point::new(200.0, 150.0));
}
/// `tool.setOption` refuses a Symbolism Tools Options value of the wrong kind or name, and the
/// tool's options stay as they were.
#[test]
fn tool_set_option_refuses_bad_symbolism_options() {
let mut s = session();
let before = s.tool_options_of("symbolSizer");
for (key, bad, want) in [
("method", json!("smooth"), "`method` must be one of userDefined, average, random"),
("sprayStain", json!("random"), "`sprayStain` must be one of average, userDefined"),
("usePressure", json!("yes"), "`usePressure` must be true or false"),
("diameter", json!("big"), "`diameter` must be a number from 2 to 2000"),
("style", json!(3), "`style` must be a string or null"),
("diameter", json!(1), "`diameter` must be a number from 2 to 2000"),
] {
let r = s.set_tool_option_cmd(&json!({"tool": "symbolSizer", "values": {key: bad}}));
assert_eq!(r, Err(want.to_string()), "{key}");
assert_eq!(s.tool_options_of("symbolSizer"), before, "{key}");
}
let r = s.set_tool_option_cmd(&json!({"tool": "symbolSizer", "values": {"method": "random", "sprayStain": "userDefined"}})).unwrap();
assert_eq!((r["method"].as_str(), r["sprayStain"].as_str()), (Some("random"), Some("userDefined")));
// Every option the options dialog sends is taken, together.
let all = json!({
"diameter": 100.0, "intensity": 6.0, "density": 4.0, "usePressure": true, "method": "average", "showBrush": false,
"sprayScrunch": "userDefined", "spraySize": "userDefined", "spraySpin": "userDefined", "sprayScreen": "userDefined",
"sprayStain": "average", "sprayStyle": "userDefined", "proportional": false, "affectsDensity": true,
});
let r = s.set_tool_option_cmd(&json!({"tool": "symbolSizer", "values": all})).unwrap();
for (key, v) in all.as_object().unwrap() {
assert_eq!(&r[key], v, "{key}");
}
}
/// With `usePressure` each point's pen pressure is the intensity there; without it the pressure is
/// not used. A pressure that isn't a number is an error.
#[test]
@@ -316,6 +390,13 @@ fn pen_pressure_is_the_intensity_with_use_pressure() {
json!({"tool": tool, "points": [[200, 150, "hard"]], "usePressure": true}),
"a point's pressure must be a number, not \"hard\"",
);
// Also on a point without coordinates, beside one that has them.
refused(
&mut s,
"symbol.adjust",
json!({"tool": tool, "points": [[200, 150], [null, 0, "bad"]], "usePressure": true}),
"a point's pressure must be a number, not \"bad\"",
);
}
for key in ["usePressure", "proportional", "affectsDensity"] {
let mut p = json!({"tool": "size", "points": [[200, 150]]});
@@ -644,6 +725,45 @@ fn set_density_starts_from_the_density_a_set_was_sprayed_at() {
assert!((center(&s, a).x - (150.0 - 50.0 * 0.25 / 0.65)).abs() < 1e-9, "{:?}", center(&s, a));
}
/// A set duplicated packs from the density recorded for its source, and a pasted set from the
/// density its source had at Copy: after Cut, after the source is given another density, and in
/// another document.
#[test]
fn a_copied_set_packs_from_the_density_of_its_source() {
for copy in ["duplicate", "paste", "cut", "changed after copy", "other document"] {
let mut s = session();
let row: Vec<Value> = (0..4).map(|i| json!([60.0 + 60.0 * f64::from(i), 150.0])).collect();
let set =
NodeId(s.execute("symbol.spray", &json!({"name": "Dot", "points": row, "radius": 4, "density": 2})).unwrap()["id"].as_u64().unwrap());
s.select(|_, sel| sel.set([set])).unwrap();
let first = match copy {
"duplicate" => "edit.duplicate",
"cut" => "edit.cut",
_ => "edit.copy",
};
s.execute(first, &json!({})).unwrap();
if copy == "changed after copy" {
s.execute("symbol.setDensity", &json!({"from": 5, "to": 9, "ids": [set.0]})).unwrap();
}
if copy == "other document" {
s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
}
if copy != "duplicate" {
s.execute("edit.paste", &json!({})).unwrap();
}
let copied = s.doc().unwrap().selection.objects.clone();
assert!(copied.len() == 1 && (copy == "other document" || copied[0] != set), "{copy}: {copied:?}");
let ids = members(&s, copied[0]);
let xs = |s: &Session| ids.iter().map(|id| center(s, *id).x).collect::<Vec<_>>();
let was = xs(&s);
let middle = was.iter().sum::<f64>() / 4.0;
s.execute("symbol.setDensity", &json!({"from": 5, "to": 9, "ids": [copied[0].0]})).unwrap();
for (before, after) in was.iter().zip(xs(&s)) {
assert!((after - (middle + (before - middle) * 0.25 / 0.95)).abs() < 1e-9, "{copy}: {before} -> {after}");
}
}
}
/// A set of one instance takes the new density without moving, as one undo step, so a later change
/// packs it from that density; setting the density it already has adds no undo step.
#[test]
@@ -719,6 +839,102 @@ fn set_density_refuses_bad_densities_and_objects_without_a_set() {
assert!(state(&s) == before);
}
/// The Symbol Styler applies the style gradually, by the brush's strength at the instance: the pen
/// pressure with Use Pressure Pen, else the intensity, less toward the brush's edge. Random gives
/// each instance a share of that amount.
#[test]
fn the_styler_applies_the_style_by_the_brushs_strength() {
let styled = |extra: Value, x: f64| {
let mut s = session();
let a = dot(&mut s, 100.0, 150.0);
let id = s.execute("shape.rectangle", &json!({"x": 300, "y": 250, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap();
s.execute("paint.setFill", &json!({"color": "#0000ff"})).unwrap();
s.execute("graphicStyle.new", &json!({"name": "Blue", "id": id})).unwrap();
s.select(|_, sel| sel.clear()).unwrap();
let mut p = json!({"tool": "style", "points": [[x, 150]], "radius": 10, "style": "Blue"});
p.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
adjust(&mut s, p);
node(&s, a).appearance.fill().map_or(0.0, |f| f.opacity)
};
let near = |a: f32, b: f32| (a - b).abs() < 1e-6;
assert!(near(styled(json!({"intensity": 10}), 100.0), 1.0), "full strength at the center");
assert!(near(styled(json!({"intensity": 5}), 100.0), 0.5));
assert!(near(styled(json!({"intensity": 10}), 105.0), 0.5), "half way to the edge");
assert!(near(styled(json!({"usePressure": true, "points": [[100, 150, 0.25]]}), 100.0), 0.25));
assert!(near(styled(json!({"usePressure": true, "points": [[100, 150, 1.0]]}), 100.0), 1.0));
assert_eq!(styled(json!({"usePressure": true, "points": [[100, 150, 0.0]]}), 100.0), 0.0, "no pressure, no style");
// Random: instances the same distance from the point take different amounts, each from none to
// the User Defined amount there (0.25: pressure 0.5, half way to the brush's edge).
let mut s = session();
let ring: Vec<NodeId> = (0..6)
.map(|i| {
let a = f64::from(i) * std::f64::consts::TAU / 6.0;
dot(&mut s, 100.0 + 5.0 * a.cos(), 150.0 + 5.0 * a.sin())
})
.collect();
let id = s.execute("shape.rectangle", &json!({"x": 300, "y": 250, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap();
s.execute("paint.setFill", &json!({"color": "#0000ff"})).unwrap();
s.execute("graphicStyle.new", &json!({"name": "Blue", "id": id})).unwrap();
s.select(|_, sel| sel.clear()).unwrap();
adjust(&mut s, json!({"tool": "style", "points": [[100, 150, 0.5]], "radius": 10, "usePressure": true, "method": "random", "style": "Blue"}));
let amounts: Vec<f32> = ring.iter().map(|a| node(&s, *a).appearance.fill().map_or(0.0, |f| f.opacity)).collect();
assert!(amounts.iter().all(|a| *a <= 0.25 + 1e-6), "{amounts:?}");
assert!(amounts.iter().any(|a| *a > 0.0), "{amounts:?}");
assert!(amounts.iter().any(|a| (a - amounts[0]).abs() > 1e-6), "{amounts:?}");
}
/// A sprayed instance's Average stain is the stain of the nearest instance whose stain shows: one
/// at no opacity is passed over and counts as no stain in the mean amount.
#[test]
fn average_spray_passes_over_a_stain_at_no_opacity() {
use vectorcraft_color::{Color, Paint};
let mut s = session();
let set =
NodeId(s.execute("symbol.spray", &json!({"name": "Dot", "points": [[100, 150], [130, 150]], "radius": 4})).unwrap()["id"].as_u64().unwrap());
let ids = members(&s, set);
assert_eq!(ids.len(), 2);
s.edit("Stains", |d, _| {
for (id, color, amount) in [(ids[0], Color::rgb(1.0, 0.0, 0.0), 0.0), (ids[1], Color::rgb(0.0, 0.0, 1.0), 1.0)] {
let n = d.node_mut(id).unwrap();
n.appearance.items.retain(|i| !matches!(i, vectorcraft_doc::AppearanceItem::Fill(_)));
let mut f = vectorcraft_doc::FillLayer::new(Paint::solid(color));
f.opacity = amount;
n.appearance.items.insert(0, vectorcraft_doc::AppearanceItem::Fill(f));
}
Ok(())
})
.unwrap();
s.execute("symbol.spray", &json!({"name": "Dot", "points": [[100, 150]], "radius": 40})).unwrap();
let new: Vec<NodeId> = members(&s, set).into_iter().filter(|id| !ids.contains(id)).collect();
assert_eq!(new.len(), 1);
let f = node(&s, new[0]).appearance.fill().cloned().unwrap();
assert_eq!(f.paint, Paint::solid(Color::rgb(0.0, 0.0, 1.0)));
assert!((f.opacity - 0.5).abs() < 1e-6, "{}", f.opacity);
}
/// The Symbol Shifter moves an instance whose transform flattens it (it has no size), as it moves
/// any other, and counts it.
#[test]
fn the_shifter_moves_an_instance_without_a_size() {
let mut s = session();
let a = dot(&mut s, 200.0, 150.0);
s.edit("Flatten", |d, _| {
if let Some(NodeKind::SymbolInstance { xf, .. }) = d.node_mut(a).map(|n| &mut n.kind) {
*xf = Affine::new([0.0, 0.0, 0.0, 0.0, 200.0, 150.0]);
}
Ok(())
})
.unwrap();
let r = adjust(&mut s, json!({"tool": "shift", "points": [[200, 150], [210, 150]], "radius": 40, "intensity": 10}));
assert_eq!(r["count"], 1);
assert!(center(&s, a).x > 200.0, "{:?}", center(&s, a));
// Average has no mean of such instances to move toward: it leaves them as they are.
let (before, x) = (state(&s), center(&s, a).x);
let r = adjust(&mut s, json!({"tool": "screen", "method": "average", "points": [[x, 150]], "radius": 40, "intensity": 10}));
assert_eq!(r["count"], 0);
assert!(state(&s) == before);
}
/// An instance with no size is shifted and screened as before; only Average, which needs its size,
/// leaves it as it is.
#[test]
@@ -759,6 +975,29 @@ fn an_instance_without_a_size_is_changed_by_every_method_but_average() {
assert!(state(&s) == before);
}
/// Average Stainer: an instance whose stain is at no opacity has no stain of its own, so it takes
/// the stain the mean picks, not its hidden paint.
#[test]
fn average_stain_replaces_a_stain_at_no_opacity() {
use vectorcraft_color::{Color, Paint};
let mut s = session();
let (a, b) = (dot(&mut s, 100.0, 150.0), dot(&mut s, 120.0, 150.0));
s.edit("Stains", |d, _| {
for (id, color, amount) in [(a, Color::rgb(1.0, 0.0, 0.0), 0.0), (b, Color::rgb(0.0, 0.0, 1.0), 1.0)] {
let n = d.node_mut(id).unwrap();
let mut f = vectorcraft_doc::FillLayer::new(Paint::solid(color));
f.opacity = amount;
n.appearance.items.insert(0, vectorcraft_doc::AppearanceItem::Fill(f));
}
Ok(())
})
.unwrap();
adjust(&mut s, json!({"tool": "stain", "method": "average", "points": [[100, 150]], "radius": 40, "intensity": 10}));
let f = node(&s, a).appearance.fill().cloned().unwrap();
assert_eq!(f.paint, Paint::solid(Color::rgb(0.0, 0.0, 1.0)));
assert!(f.opacity > 0.0, "{}", f.opacity);
}
/// A stroke that leaves every instance under the brush as it is (each already at full stain, or
/// at the least opacity) counts none and adds no undo step.
#[test]
+272
View File
@@ -0,0 +1,272 @@
//! The symbolism tools' Shift forms in `symbol.adjust {shift}`: the Symbol Shifter's stacking
//! order, the Symbol Sizer keeping the set's density, and the Symbol Stainer and Symbol Styler
//! keeping their amount while the color or style changes.
use serde_json::{Value, json};
use vectorcraft_doc::{Document, Node, NodeKind};
use vectorcraft_geom::Point;
use crate::*;
/// A document with the 20 pt square symbol "Dot" and nothing selected.
fn session() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap();
s.execute("symbol.new", &json!({"name": "Dot"})).unwrap();
s.select(|_, sel| sel.clear()).unwrap();
s
}
/// An instance of Dot centered on (`x`, `y`), not selected.
fn dot(s: &mut Session, x: f64, y: f64) -> NodeId {
let id = NodeId(s.execute("symbol.place", &json!({"name": "Dot", "x": x, "y": y})).unwrap()["id"].as_u64().unwrap());
s.select(|_, sel| sel.clear()).unwrap();
id
}
fn node(s: &Session, id: NodeId) -> Node {
s.doc().unwrap().doc.node(id).cloned().unwrap()
}
fn center(s: &Session, id: NodeId) -> Point {
match node(s, id).kind {
NodeKind::SymbolInstance { xf, .. } => xf * Point::ZERO,
other => panic!("not an instance: {other:?}"),
}
}
fn width(s: &Session, id: NodeId) -> f64 {
node(s, id).geometric_bounds().unwrap().width()
}
fn undo_len(s: &Session) -> usize {
s.doc().unwrap().history.undo.len()
}
fn state(s: &Session) -> (Document, usize) {
((*s.doc().unwrap().doc).clone(), undo_len(s))
}
fn adjust(s: &mut Session, p: Value) -> Value {
s.execute("symbol.adjust", &p).unwrap()
}
/// The children of symbol set `set`, in stacking order (the first is at the back).
fn members(s: &Session, set: NodeId) -> Vec<NodeId> {
node(s, set).children().unwrap().iter().map(|c| c.id).collect()
}
/// The instance's fill: its color as RGB and its amount.
fn fill(s: &Session, id: NodeId) -> Option<([f32; 3], f32)> {
node(s, id).appearance.fill().map(|f| (f.paint.color().map_or([0.0; 3], |c| c.to_rgb()), f.opacity))
}
/// A symbol set of four instances in a row at x = 40, 120, 200 and 280, selected.
fn row(s: &mut Session) -> (NodeId, Vec<NodeId>) {
let pts: Vec<Value> = (0..4).map(|i| json!([40.0 + 80.0 * f64::from(i), 150.0])).collect();
let set = NodeId(s.execute("symbol.spray", &json!({"name": "Dot", "points": pts, "radius": 4})).unwrap()["id"].as_u64().unwrap());
let ids = members(s, set);
assert_eq!(ids.len(), 4);
(set, ids)
}
/// Shift-click with the Symbol Shifter brings the instances under the brush one place forward in
/// the set, and Alt+Shift-click sends them one place backward, without moving them on the canvas.
#[test]
fn shift_click_with_the_shifter_changes_the_stacking_order() {
let mut s = session();
let (set, ids) = row(&mut s);
let centers: Vec<Point> = ids.iter().map(|id| center(&s, *id)).collect();
let click = |s: &mut Session, x: f64, alt: bool| {
adjust(s, json!({"tool": "shift", "points": [[x, 150]], "radius": 10, "intensity": 10, "shift": true, "alt": alt}))["count"].clone()
};
let steps = undo_len(&s);
assert_eq!(click(&mut s, 120.0, false), 1);
assert_eq!(members(&s, set), [ids[0], ids[2], ids[1], ids[3]]);
assert_eq!(undo_len(&s), steps + 1, "one undo step");
assert_eq!(ids.iter().map(|id| center(&s, *id)).collect::<Vec<_>>(), centers, "nothing moves on the canvas");
assert_eq!(click(&mut s, 120.0, false), 1);
assert_eq!(members(&s, set), [ids[0], ids[2], ids[3], ids[1]]);
// Already in front of the others: nothing changes and no undo step is added.
let before = state(&s);
assert_eq!(click(&mut s, 120.0, false), 0);
assert!(state(&s) == before);
// Alt sends it back one place at a time; at the back it stays.
assert_eq!(click(&mut s, 120.0, true), 1);
assert_eq!(members(&s, set), [ids[0], ids[2], ids[1], ids[3]]);
click(&mut s, 120.0, true);
click(&mut s, 120.0, true);
assert_eq!(members(&s, set), [ids[1], ids[0], ids[2], ids[3]]);
assert_eq!(click(&mut s, 120.0, true), 0);
// Two instances under the brush move together past the next one.
s.execute("edit.undo", &json!({})).unwrap();
let both = adjust(&mut s, json!({"tool": "shift", "points": [[40, 150], [120, 150]], "radius": 10, "intensity": 10, "shift": true}));
assert_eq!(both["count"], 2);
assert_eq!(members(&s, set), [ids[2], ids[0], ids[1], ids[3]]);
// Without Shift a drag moves the instances, as before.
adjust(&mut s, json!({"tool": "shift", "points": [[280, 150], [290, 150]], "radius": 30, "intensity": 10}));
assert!(center(&s, ids[3]).x > centers[3].x);
}
/// Shift with the Symbol Sizer resizes the instances and keeps their centers where they are, even
/// with Resizing Affects Density.
#[test]
fn shift_with_the_sizer_keeps_the_density() {
let at = |affects: bool, shift: bool| {
let mut s = session();
let a = dot(&mut s, 220.0, 150.0);
adjust(
&mut s,
json!({"tool": "size", "points": [[200, 150], [200, 150]], "radius": 60, "intensity": 10, "affectsDensity": affects, "shift": shift}),
);
(center(&s, a), width(&s, a))
};
let (moved, _) = at(true, false);
assert!(moved.x > 220.5, "{moved:?}");
let (kept, grown) = at(true, true);
assert!((kept.x - 220.0).abs() < 1e-9 && (kept.y - 150.0).abs() < 1e-9 && grown > 20.5, "{kept:?} {grown}");
// It resizes as the Sizer does with Resizing Affects Density off.
assert_eq!(at(false, false), (kept, grown));
assert_eq!(at(false, true), (kept, grown));
}
/// Shift with the Symbol Stainer keeps the stain's amount and moves its color toward the fill
/// color; an instance without a stain is left as it is.
#[test]
fn shift_with_the_stainer_keeps_the_amount_and_changes_the_color() {
let mut s = session();
let (a, b) = (dot(&mut s, 100.0, 150.0), dot(&mut s, 300.0, 150.0));
adjust(&mut s, json!({"tool": "stain", "points": [[100, 150], [100, 150]], "radius": 5, "intensity": 10, "color": "#ff0000"}));
let (red, amount) = fill(&s, a).unwrap();
assert!(amount > 0.2 && red[0] > 0.99 && red[2] < 0.01, "{red:?} {amount}");
// A second fill below the stain, which Shift leaves as it is.
s.edit("Add fill", |d, _| {
let n = d.node_mut(a).unwrap();
let lower = n.appearance.fill().unwrap().clone();
n.appearance.items.insert(0, vectorcraft_doc::AppearanceItem::Fill(vectorcraft_doc::FillLayer { opacity: 0.5, ..lower }));
Ok(())
})
.unwrap();
let lower = node(&s, a).appearance.items[0].clone();
let stain = |s: &mut Session, x: f64| {
adjust(s, json!({"tool": "stain", "points": [[x, 150], [x, 150]], "radius": 5, "intensity": 10, "color": "#0000ff", "shift": true}))
};
assert_eq!(stain(&mut s, 100.0)["count"], 1);
let (color, kept) = fill(&s, a).unwrap();
assert_eq!(kept, amount, "the amount stays");
assert!(color[0] < red[0] && color[2] > 0.01, "toward blue: {color:?}");
assert_eq!((node(&s, a).appearance.items.len(), &node(&s, a).appearance.items[0]), (2, &lower), "the other fill stays");
// More strokes go on toward blue, with the amount still the same.
for _ in 0..30 {
stain(&mut s, 100.0);
}
let (bluer, kept) = fill(&s, a).unwrap();
assert_eq!(kept, amount);
assert!(bluer[2] > 0.9 && bluer[0] < 0.1, "{bluer:?}");
// Alt has no effect with Shift.
let green = json!({"tool": "stain", "points": [[100, 150]], "radius": 5, "intensity": 10, "color": "#00ff00", "shift": true});
adjust(&mut s, green.clone());
let plain = fill(&s, a);
s.execute("edit.undo", &json!({})).unwrap();
let mut with_alt = green;
with_alt["alt"] = json!(true);
adjust(&mut s, with_alt);
assert_eq!(fill(&s, a), plain);
// No stain on b: nothing changes and no undo step is added.
let before = state(&s);
assert_eq!(stain(&mut s, 300.0)["count"], 0);
assert!(state(&s) == before && fill(&s, b).is_none());
}
/// Shift with the Symbol Styler keeps the amount of the instance's stain or style and moves its
/// fill toward the selected style's fill.
#[test]
fn shift_with_the_styler_keeps_the_amount_and_changes_the_style() {
let mut s = session();
let a = dot(&mut s, 100.0, 150.0);
let id = s.execute("shape.rectangle", &json!({"x": 300, "y": 250, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap();
s.execute("paint.setFill", &json!({"color": "#0000ff"})).unwrap();
s.execute("graphicStyle.new", &json!({"name": "Blue", "id": id})).unwrap();
s.select(|_, sel| sel.clear()).unwrap();
// A red stain at part strength.
adjust(&mut s, json!({"tool": "stain", "points": [[100, 150]], "radius": 5, "intensity": 10, "color": "#ff0000"}));
let (red, amount) = fill(&s, a).unwrap();
assert!(red[0] > 0.99 && amount > 0.0 && amount < 0.5, "{red:?} {amount}");
// Half the brush's strength at a point 2.5 pt from the instance: half way to blue.
adjust(&mut s, json!({"tool": "style", "points": [[102.5, 150]], "radius": 5, "intensity": 10, "style": "Blue", "shift": true}));
let (mixed, kept) = fill(&s, a).unwrap();
assert_eq!(kept, amount);
assert!(mixed[0] < 0.99 && mixed[2] > 0.01, "{mixed:?}");
// At the brush's center with full intensity it takes the style's fill.
adjust(&mut s, json!({"tool": "style", "points": [[100, 150]], "radius": 5, "intensity": 10, "style": "Blue", "shift": true}));
let (blue, kept) = fill(&s, a).unwrap();
assert_eq!(kept, amount);
assert!(blue[2] > 0.99 && blue[0] < 0.01, "{blue:?}");
}
/// A stain or style with no form between it and the new paint (a pattern and a solid color) takes
/// the new paint at once, at any strength, and keeps its amount.
#[test]
fn shift_changes_a_paint_that_has_no_form_in_between() {
use vectorcraft_color::Paint;
let mut s = session();
let a = dot(&mut s, 100.0, 150.0);
s.edit("Pattern fill", |d, _| {
let mut f = vectorcraft_doc::FillLayer::new(Paint::Pattern { pattern: "Tile".into(), xf: Default::default() });
f.opacity = 0.4;
d.node_mut(a).unwrap().appearance.items.insert(0, vectorcraft_doc::AppearanceItem::Fill(f));
Ok(())
})
.unwrap();
// Low intensity, near the brush's edge: far below half strength.
let r = adjust(&mut s, json!({"tool": "stain", "points": [[104, 150]], "radius": 5, "intensity": 1, "color": "#ff0000", "shift": true}));
assert_eq!(r["count"], 1);
let f = node(&s, a).appearance.fill().cloned().unwrap();
assert_eq!(f.opacity, 0.4, "the amount stays");
assert!(f.paint.color().is_some_and(|c| c.to_rgb()[0] > 0.99), "{:?}", f.paint);
}
/// A style name the document has no style for (the Styler's style from another document, or one
/// since renamed or deleted) moves the fill toward the document's first style after the default
/// one, as no name does, and the stain's amount stays.
#[test]
fn the_styler_takes_the_first_style_for_a_name_the_document_lacks() {
use vectorcraft_color::{Color, Paint};
let styled = |style: Option<&str>| {
let mut s = session();
let a = dot(&mut s, 100.0, 150.0);
s.execute("paint.setFill", &json!({"color": "#00ff00"})).unwrap();
s.select(|_, sel| sel.clear()).unwrap();
adjust(&mut s, json!({"tool": "stain", "points": [[100, 150]], "radius": 5, "intensity": 10, "color": "#ff0000"}));
let mut p = json!({"tool": "style", "points": [[100, 150]], "radius": 5, "intensity": 10, "shift": true});
if let Some(n) = style {
p["style"] = json!(n);
}
let stained = node(&s, a).appearance.fill().map(|f| f.opacity);
adjust(&mut s, p);
let f = node(&s, a).appearance.fill().cloned().unwrap();
assert_eq!(Some(f.opacity), stained, "the amount stays");
let first = s.doc().unwrap().doc.graphic_styles[1].appearance.fill_paint();
(f.paint, first)
};
let (missing, first) = styled(Some("No Such Style"));
let (none, _) = styled(None);
assert_eq!(missing, none);
// The paint is the first style's, not the active fill color.
assert_eq!(none, first);
assert_ne!(none, Paint::solid(Color::rgb(0.0, 1.0, 0.0)));
}
/// A `shift` that is not true, false or null is refused and changes nothing.
#[test]
fn a_bad_shift_is_refused() {
let mut s = session();
dot(&mut s, 100.0, 150.0);
for tool in ["shift", "size", "stain", "style"] {
let before = state(&s);
let r = s.execute("symbol.adjust", &json!({"tool": tool, "points": [[100, 150]], "shift": "yes"}));
assert!(matches!(&r, Err(EngineError::BadParams { msg, .. }) if msg == "`shift` must be true or false"), "{tool}: {r:?}");
assert!(state(&s) == before);
}
}
+80
View File
@@ -138,6 +138,86 @@ fn a_dropped_press_does_not_keep_what_its_drag_changed() {
assert_eq!(s.prefs.tool_settings["polygon"]["sides"], json!(7), "and stores its sides");
}
/// An option set with `tool.setOption` while a press is held survives the dropped press, in the
/// tool and in the stored options, while what the drag itself changed is put back in both.
#[test]
fn an_option_set_during_a_dropped_press_is_kept() {
let mut s = session();
select(&mut s, "rectangularGrid");
let v = ViewInfo { smart_guides: false, ..Default::default() };
s.pointer(&PointerEvent::new(PointerKind::Down, 100.0, 100.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Drag, 200.0, 180.0), v).unwrap();
s.tool_key(ToolKey::Up, Mods::default(), v).unwrap();
s.tool_key(ToolKey::Right, Mods::default(), v).unwrap();
assert_eq!((s.tool_options()["rows"].clone(), s.tool_options()["columns"].clone()), (json!(6), json!(6)));
s.set_tool_option_cmd(&json!({"key": "columns", "value": 9})).unwrap();
s.drop_tool_press(v).unwrap();
let o = s.tool_options();
assert_eq!((o["rows"].clone(), o["columns"].clone()), (json!(5), json!(9)), "the drag's rows go back; the set columns stay");
let saved = &s.prefs.tool_settings["rectangularGrid"];
assert_eq!((saved["rows"].clone(), saved["columns"].clone()), (json!(5), json!(9)), "the drag's rows are not stored; the set columns are");
select(&mut s, "selection");
select(&mut s, "rectangularGrid");
let o = s.tool_options();
assert_eq!((o["rows"].clone(), o["columns"].clone()), (json!(5), json!(9)), "a tool switch keeps the set columns");
// The same through the desktop app's setter.
s.pointer(&PointerEvent::new(PointerKind::Down, 100.0, 100.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Drag, 200.0, 180.0), v).unwrap();
s.tool_key(ToolKey::Up, Mods::default(), v).unwrap();
s.set_tool_option("columns", &json!(3));
s.drop_tool_press(v).unwrap();
let o = s.tool_options();
assert_eq!((o["rows"].clone(), o["columns"].clone()), (json!(5), json!(3)));
let saved = &s.prefs.tool_settings["rectangularGrid"];
assert_eq!((saved["rows"].clone(), saved["columns"].clone()), (json!(5), json!(3)));
}
/// A Corner Radius preference set while a Rounded Rectangle press is held survives the dropped
/// press, in the tool and in the preference.
#[test]
fn a_corner_radius_set_during_a_dropped_press_is_kept() {
let mut s = session();
select(&mut s, "roundedRectangle");
let v = ViewInfo { smart_guides: false, ..Default::default() };
s.pointer(&PointerEvent::new(PointerKind::Down, 100.0, 100.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Drag, 200.0, 180.0), v).unwrap();
let mut p = s.prefs.clone();
p.corner_radius = 30.0;
s.apply_prefs(p);
s.drop_tool_press(v).unwrap();
assert_eq!(s.tool_options()["cornerRadius"].as_f64(), Some(30.0), "the tool keeps the new radius");
assert_eq!(s.prefs.corner_radius, 30.0, "the preference keeps it");
}
/// An option set with `tool.setOption` on a tool that lent a selection tool for a Cmd-drag
/// survives the dropped press, in the tool and in the stored options. So does a Corner Radius
/// preference set while the Rounded Rectangle lends one.
#[test]
fn an_option_set_on_a_lending_tool_during_a_dropped_press_is_kept() {
let mut s = session();
select(&mut s, "rectangularGrid");
let v = ViewInfo { smart_guides: false, ..Default::default() };
let cmd = Mods { cmd: true, ..Default::default() };
s.pointer(&PointerEvent::new(PointerKind::Down, 100.0, 100.0).with_mods(cmd), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Drag, 200.0, 180.0).with_mods(cmd), v).unwrap();
assert_eq!(s.lender.as_ref().map(|t| t.id()), Some("rectangularGrid"), "the press lent a selection tool");
s.set_tool_option_cmd(&json!({"tool": "rectangularGrid", "key": "columns", "value": 9})).unwrap();
s.drop_tool_press(v).unwrap();
assert_eq!(s.tool_id(), "rectangularGrid", "the lending tool is back");
assert_eq!(s.tool_options()["columns"], json!(9), "the tool keeps the set columns");
assert_eq!(s.prefs.tool_settings["rectangularGrid"]["columns"], json!(9), "and stores them");
select(&mut s, "roundedRectangle");
s.pointer(&PointerEvent::new(PointerKind::Down, 100.0, 100.0).with_mods(cmd), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Drag, 200.0, 180.0).with_mods(cmd), v).unwrap();
assert_eq!(s.lender.as_ref().map(|t| t.id()), Some("roundedRectangle"), "the press lent a selection tool");
let mut p = s.prefs.clone();
p.corner_radius = 30.0;
s.apply_prefs(p);
s.drop_tool_press(v).unwrap();
assert_eq!(s.tool_options()["cornerRadius"].as_f64(), Some(30.0), "the tool keeps the new radius");
assert_eq!(s.prefs.corner_radius, 30.0, "the preference keeps it");
}
/// A dropped Pen press drops only the anchor it was placing: the path being drawn goes on with
/// the next click.
#[test]
+400
View File
@@ -754,6 +754,406 @@ fn distort_perspective_midpoint_is_projective() {
assert!((c.y - 100.0 / 6.0).abs() < 1e-3, "{c:?}");
}
/// A 2 × 2 px image placed at (0, 0)–(100, 100), selected.
fn placed_image(s: &mut Session) -> NodeId {
s.edit("Place", |d, sel| {
d.images.insert("pic".into(), vectorcraft_doc::ImageBlob::png(vec![]));
let id = d.alloc_id();
let im = vectorcraft_doc::ImageObject {
key: "pic".into(),
width: 2,
height: 2,
xf: vectorcraft_geom::Affine::scale(50.0),
link: None,
placement: Default::default(),
pixels: None,
};
d.insert(d.default_layer(), 0, Node::new(id, vectorcraft_doc::NodeKind::Image(Box::new(im))))?;
sel.set([id]);
Ok(id)
})
.unwrap()
}
fn corners(s: &Session, id: NodeId) -> [Point; 4] {
s.doc().unwrap().doc.node(id).unwrap().image_corners().unwrap()
}
fn assert_corners(got: [Point; 4], want: [(f64, f64); 4]) {
for (g, (x, y)) in got.iter().zip(want) {
assert!(g.distance(Point::new(x, y)) < 1e-9, "{got:?} against {want:?}");
}
}
/// Perspective Distort and Free Distort put an image's corners exactly on the handles, in one
/// undo step; the image is bounded and clicked by its corners, and a move takes them along.
#[test]
fn distort_puts_an_images_corners_on_the_handles() {
for want in [[(40.0, 0.0), (60.0, 0.0), (100.0, 100.0), (0.0, 100.0)], [(10.0, 5.0), (90.0, 0.0), (120.0, 110.0), (0.0, 100.0)]] {
let mut s = session();
let img = placed_image(&mut s);
let undo = undo_len(&s);
let corners_json: Vec<[f64; 2]> = want.iter().map(|(x, y)| [*x, *y]).collect();
s.execute("object.distort", &json!({ "corners": corners_json })).unwrap();
assert_eq!(undo_len(&s), undo + 1);
assert_corners(corners(&s, img), want);
assert!(s.doc().unwrap().doc.node(img).unwrap().is_distorted_image());
let b = bounds(&s, img);
let xs = want.map(|c| c.0);
let ys = want.map(|c| c.1);
let near = |a: f64, b: f64| (a - b).abs() < 1e-9;
assert!(near(b.x0, xs.iter().copied().fold(f64::MAX, f64::min)) && near(b.x1, xs.iter().copied().fold(f64::MIN, f64::max)), "{b:?}");
assert!(near(b.y0, ys.iter().copied().fold(f64::MAX, f64::min)) && near(b.y1, ys.iter().copied().fold(f64::MIN, f64::max)), "{b:?}");
s.execute("object.move", &json!({"dx": 10, "dy": 20})).unwrap();
assert_corners(corners(&s, img), want.map(|(x, y)| (x + 10.0, y + 20.0)));
s.execute("edit.undo", &json!({})).unwrap();
s.execute("edit.undo", &json!({})).unwrap();
assert_corners(corners(&s, img), [(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)]);
assert!(!s.doc().unwrap().doc.node(img).unwrap().is_distorted_image());
}
// Clicks: inside the trapezoid hits the image; inside its old square but outside the
// trapezoid does not.
let mut s = session();
let img = placed_image(&mut s);
s.execute("object.distort", &json!({ "corners": [[40, 0], [60, 0], [100, 100], [0, 100]] })).unwrap();
let doc = &s.doc().unwrap().doc;
let opt = vectorcraft_doc::hit::HitOptions::default();
assert_eq!(vectorcraft_doc::hit::hit_test(doc, Point::new(50.0, 50.0), opt).map(|h| h.leaf), Some(img));
assert_eq!(vectorcraft_doc::hit::hit_test(doc, Point::new(5.0, 10.0), opt).map(|h| h.leaf), None);
}
/// Distorted together with a path, the image's corners and the path's anchors follow one warp.
#[test]
fn distort_moves_an_image_and_a_path_as_one() {
let mut s = session();
let img = placed_image(&mut s);
let path = rect(&mut s, 100.0, 0.0, 100.0, 100.0);
s.execute("select.set", &json!({"ids": [img.0, path.0]})).unwrap();
s.execute("object.distort", &json!({"corners": [[0, 0], [200, 0], [200, 100], [50, 100]]})).unwrap();
let d = &s.doc().unwrap().doc;
let anchors: Vec<Point> = d.node(path).unwrap().path_data().unwrap().anchors().map(|(_, _, a)| a.p).collect();
let q = corners(&s, img);
// The image's right edge and the path's left edge were one line, and stay one where the warp
// moves it.
assert!(q[2].distance(Point::new(100.0, 100.0)) > 1.0, "{q:?}");
for p in [q[1], q[2]] {
assert!(anchors.iter().any(|a| a.distance(p) < 1e-9), "{p:?} not in {anchors:?}");
}
}
/// Corners that would fold an image over are refused: nothing changes and no undo step is kept.
/// A distorted image keeps its distortion where commands that cannot keep it are asked to work.
#[test]
fn distort_refuses_a_folded_image_and_crop_and_trace_refuse_a_distorted_one() {
let mut s = session();
let img = placed_image(&mut s);
let (before, undo) = (s.doc().unwrap().doc.clone(), undo_len(&s));
let e = s.execute("object.distort", &json!({"corners": [[0, 0], [100, 0], [0, 100], [100, 100]]})).unwrap_err().to_string();
assert!(e.contains("convex"), "{e}");
assert_eq!(undo_len(&s), undo);
assert_eq!(s.doc().unwrap().doc, before);
// Three corners on one line give no perspective map at all.
let e = s.execute("object.distort", &json!({"corners": [[0, 0], [200, 0], [100, 50], [0, 100]]})).unwrap_err().to_string();
assert!(e.contains("convex"), "{e}");
assert_eq!(s.doc().unwrap().doc, before);
// A convex shape too small for a perspective map: the corners could not reach the handles.
let e = s.execute("object.distort", &json!({"corners": [[0, 0], [1e-7, 0], [8e-8, 1e-7], [0, 1e-7]]})).unwrap_err().to_string();
assert!(e.contains("too close together"), "{e}");
// The same shape far from the origin: its distance from it does not hide the missed corner.
let x = 1_000_000.0;
let e = s.execute("object.distort", &json!({"corners": [[x, 0], [x + 1e-7, 0], [x + 8e-8, 1e-7], [x, 1e-7]]})).unwrap_err().to_string();
assert!(e.contains("too close together"), "{e}");
// A long, thin shape with one side all but gone.
let e = s.execute("object.distort", &json!({"corners": [[0, 0], [1_000_000, 0], [1_000_000, 1e-19], [0, 1]]})).unwrap_err().to_string();
assert!(e.contains("too close together"), "{e}");
assert_eq!(s.doc().unwrap().doc, before);
assert_eq!(undo_len(&s), undo);
// A small shape near the edge of the canvas is still distorted.
let o = vectorcraft_doc::MAX_COORD - 2.0;
let far = [[o, o], [o + 1.0, o], [o + 0.2130712, o + 1.0], [o, o + 1.0]];
s.execute("object.distort", &json!({ "from": [0, 0, 100, 100], "corners": far })).unwrap();
assert!(s.doc().unwrap().doc.node(img).unwrap().is_distorted_image());
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(undo_len(&s), undo);
s.execute("object.distort", &json!({ "corners": [[40, 0], [60, 0], [100, 100], [0, 100]] })).unwrap();
for (cmd, params) in [
("object.cropImage", json!({})),
("imageTrace.make", json!({})),
("links.relink", json!({"path": "/nowhere/pic.png"})),
// Refused before the folder is searched, so a file missing there does not hide it.
("links.relink", json!({"folder": "/nowhere"})),
("links.embed", json!({"ids": [img.0]})),
("links.unembed", json!({})),
// Refused before any file is written.
("links.unembed", json!({"folder": "/nowhere"})),
("object.createObjectMosaic", json!({})),
("object.mesh.create", json!({})),
(
"file.place",
json!({"replace": true, "name": "b.png", "dataBase64": vectorcraft_format::base64_encode(&crate::tests_links::png(2, 2, [0, 0, 255]))}),
),
] {
let e = s.execute(cmd, &params).unwrap_err().to_string();
// Every command gives the one shared refusal, which the complete-message catalogs translate.
assert!(e.contains("is an image changed by Perspective Distort or Free Distort, which this command does not work on"), "{cmd}: {e}");
}
assert!(s.doc().unwrap().doc.node(img).unwrap().is_distorted_image());
assert_eq!(undo_len(&s), undo + 1);
// Type replaces a distorted image by its bounds, which the corners give: not refused.
let text = json!({"replace": true, "name": "note.txt", "dataBase64": vectorcraft_format::base64_encode(b"Hello")});
let out = s.execute("file.place", &text).unwrap();
let id = NodeId(out["ids"][0].as_u64().unwrap());
assert!(matches!(s.doc().unwrap().doc.node(id).unwrap().kind, vectorcraft_doc::NodeKind::Text(_)));
}
/// Create Gradient Mesh on a path and a distorted image converts the path and names the image it
/// left as it is, with the shared refusal.
#[test]
fn mesh_create_reports_the_distorted_image_it_skips() {
let mut s = session();
let img = placed_image(&mut s);
s.execute("object.distort", &json!({ "corners": [[40, 0], [60, 0], [100, 100], [0, 100]] })).unwrap();
let path = rect(&mut s, 200.0, 0.0, 100.0, 100.0);
s.execute("select.set", &json!({"ids": [img.0, path.0]})).unwrap();
let out = s.execute("object.mesh.create", &json!({"rows": 1, "cols": 1})).unwrap();
assert_eq!(out["ids"].as_array().map(Vec::len), Some(1), "{out}");
let skipped = out["skipped"].as_array().expect("the skipped image");
assert_eq!(skipped.len(), 1, "{out}");
assert_eq!(skipped[0]["id"], json!(img.0));
assert!(skipped[0]["reason"].as_str().unwrap().contains("Perspective Distort or Free Distort"), "{out}");
assert!(s.doc().unwrap().doc.node(img).unwrap().is_distorted_image());
// Without a distorted image, no `skipped`.
let other = rect(&mut s, 400.0, 0.0, 100.0, 100.0);
let out = s.execute("object.mesh.create", &json!({"ids": [other.0], "rows": 1, "cols": 1})).unwrap();
assert!(out.get("skipped").is_none(), "{out}");
}
/// A blend takes the warp's affine approximation whole, so an image inside it does not stop a
/// distort whose corners an image could not follow.
#[test]
fn distort_of_a_blend_holding_an_image_is_not_refused() {
let mut s = session();
let img = placed_image(&mut s);
let r = rect(&mut s, 200.0, 0.0, 100.0, 100.0);
let out = s.execute("object.blend.make", &json!({"ids": [img.0, r.0]})).unwrap();
let blend = NodeId(out["id"].as_u64().unwrap());
let undo = undo_len(&s);
s.execute("object.distort", &json!({"ids": [blend.0], "corners": [[0, 0], [300, 0], [100, 50], [0, 100]]})).unwrap();
assert_eq!(undo_len(&s), undo + 1);
assert!(!s.doc().unwrap().doc.node(img).unwrap().is_distorted_image());
}
/// The Control bar's Mask clips a distorted image to the shape between its corners.
#[test]
fn mask_on_a_distorted_image_follows_its_corners() {
let mut s = session();
let img = placed_image(&mut s);
let want = [(40.0, 0.0), (60.0, 0.0), (100.0, 100.0), (0.0, 100.0)];
s.execute("object.distort", &json!({ "corners": [[40, 0], [60, 0], [100, 100], [0, 100]] })).unwrap();
let out = s.execute("object.maskImage", &json!({})).unwrap();
let path = NodeId(out["path"].as_u64().unwrap());
let d = &s.doc().unwrap().doc;
let anchors: Vec<Point> = d.node(path).unwrap().path_data().unwrap().anchors().map(|(_, _, a)| a.p).collect();
assert_eq!(anchors.len(), 4, "{anchors:?}");
for (x, y) in want {
assert!(anchors.iter().any(|a| a.distance(Point::new(x, y)) < 1e-9), "{x},{y} not in {anchors:?}");
}
assert!(d.node(img).unwrap().is_distorted_image());
}
/// A Transform effect moves a distorted image's corners with it: expanded, the image stands
/// where the effect drew it.
#[test]
fn a_transform_effect_moves_a_distorted_images_corners() {
let mut s = session();
let img = placed_image(&mut s);
s.execute("object.distort", &json!({ "corners": [[40, 0], [60, 0], [100, 100], [0, 100]] })).unwrap();
s.execute("effect.apply", &json!({"ids": [img.0], "effect": "distort.transform", "params": {"moveH": 200}})).unwrap();
s.execute("select.set", &json!({"ids": [img.0]})).unwrap();
s.execute("effect.expandAppearance", &json!({})).unwrap();
let mut found = vec![];
for layer in &s.doc().unwrap().doc.layers {
layer.walk(&mut |n| {
if let Some(q) = n.image_corners() {
found.push(q);
}
});
}
let want = [(240.0, 0.0), (260.0, 0.0), (300.0, 100.0), (200.0, 100.0)];
assert!(found.iter().any(|q| q.iter().zip(want).all(|(p, (x, y))| p.distance(Point::new(x, y)) < 1e-6)), "{found:?}");
}
/// A Transform effect after a Warp effect moves a distorted image's warped pixels once: the art
/// stands where the Warp alone draws it, moved by the Transform.
#[test]
fn a_transform_after_a_warp_moves_a_distorted_image_once() {
let expanded_bounds = |transform: bool| {
let mut s = session();
let img = placed_image(&mut s);
s.execute("object.distort", &json!({ "corners": [[40, 0], [60, 0], [100, 100], [0, 100]] })).unwrap();
s.execute("effect.apply", &json!({"ids": [img.0], "effect": "warp.bulge", "params": {"bend": 50}})).unwrap();
if transform {
s.execute("effect.apply", &json!({"ids": [img.0], "effect": "distort.transform", "params": {"moveH": 200}})).unwrap();
}
s.execute("select.set", &json!({"ids": [img.0]})).unwrap();
s.execute("effect.expandAppearance", &json!({})).unwrap();
let mut images = None;
for layer in &s.doc().unwrap().doc.layers {
layer.walk(&mut |n| {
if let vectorcraft_doc::NodeKind::Image(im) = &n.kind {
let r = im.xf.transform_rect_bbox(vectorcraft_geom::Rect::new(0.0, 0.0, f64::from(im.width), f64::from(im.height)));
images = Some(images.map_or(r, |b: vectorcraft_geom::Rect| b.union(r)));
}
});
}
images.expect("the warped pieces")
};
let (alone, moved) = (expanded_bounds(false), expanded_bounds(true));
assert!((moved.x0 - alone.x0 - 200.0).abs() < 1e-6 && (moved.x1 - alone.x1 - 200.0).abs() < 1e-6, "{alone:?} {moved:?}");
assert!((moved.y0 - alone.y0).abs() < 1e-6 && (moved.y1 - alone.y1).abs() < 1e-6, "{alone:?} {moved:?}");
}
/// A raster effect's baked pixels already show the distortion: the image that replaces a
/// distorted one is placed by its own transform.
#[test]
fn baked_raster_effect_pixels_replace_a_distortion() {
let mut s = session();
let img = placed_image(&mut s);
s.execute("object.distort", &json!({ "corners": [[40, 0], [60, 0], [100, 100], [0, 100]] })).unwrap();
let v = s.doc().unwrap().doc.node(img).unwrap().clone();
let baked = Node::new(NodeId(99), v.kind.clone());
let out = crate::cmd::rasterfx::replace_with_image(v, baked);
assert!(!out.is_distorted_image());
assert!(out.extras().image_quad.is_none());
}
/// A distorted image is saved with its corners and reads back the same.
#[test]
fn a_distorted_image_saves_and_reads_back() {
let mut s = session();
let img = placed_image(&mut s);
s.execute("object.distort", &json!({ "corners": [[40, 0], [60, 0], [100, 100], [0, 100]] })).unwrap();
let doc = &s.doc().unwrap().doc;
let bytes = vectorcraft_format::save(doc, false);
let back = vectorcraft_format::load(&bytes).unwrap();
assert_eq!(back.node(img).unwrap().image_corners(), doc.node(img).unwrap().image_corners());
assert!(back.node(img).unwrap().is_distorted_image());
assert!(String::from_utf8_lossy(&bytes).contains("image_quad"));
// An image without a distortion is saved without the field, and opens as it was.
let mut plain = session();
let img = placed_image(&mut plain);
let doc = &plain.doc().unwrap().doc;
let bytes = vectorcraft_format::save(doc, false);
assert!(!String::from_utf8_lossy(&bytes).contains("image_quad"));
let back = vectorcraft_format::load(&bytes).unwrap();
assert_eq!(back.node(img), doc.node(img));
// Corners in a file that fold the image over leave it placed by its transform.
let mut bad = (**doc).clone();
bad.node_mut(img).unwrap().extras_mut().image_quad =
Some(Box::new([(0.0, 0.0), (100.0, 0.0), (0.0, 100.0), (100.0, 100.0)].map(|(x, y)| Point::new(x, y))));
let back = vectorcraft_format::load(&vectorcraft_format::save(&bad, false)).unwrap();
assert!(!back.node(img).unwrap().is_distorted_image());
assert_corners(back.node(img).unwrap().image_corners().unwrap(), [(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)]);
}
/// A distort whose corners cross the warp's horizon at the image is refused with that reason, and
/// a distort that leaves a distorted image where it is records nothing.
#[test]
fn distort_names_the_horizon_and_an_unchanged_distort_of_a_distorted_image_records_nothing() {
let mut s = session();
let img = placed_image(&mut s);
let (before, undo) = (s.doc().unwrap().doc.clone(), undo_len(&s));
// The box (0, 0)-(10, 10) widens toward its bottom so fast that the warp's horizon lies at
// y = 15, inside the image.
let e = s.execute("object.distort", &json!({"from": [0, 0, 10, 10], "corners": [[0, 0], [10, 0], [20, 10], [-10, 10]]})).unwrap_err().to_string();
assert!(e.contains("horizon"), "{e}");
assert_eq!(s.doc().unwrap().doc, before);
assert_eq!(undo_len(&s), undo);
s.execute("object.distort", &json!({ "corners": [[40, 0], [60, 0], [100, 100], [0, 100]] })).unwrap();
let (before, undo) = (s.doc().unwrap().doc.clone(), undo_len(&s));
let b = bounds(&s, img);
let at = [[b.x0, b.y0], [b.x1, b.y0], [b.x1, b.y1], [b.x0, b.y1]];
s.execute("object.distort", &json!({ "from": [b.x0, b.y0, b.x1, b.y1], "corners": at })).unwrap();
assert_eq!(s.doc().unwrap().doc, before);
assert_eq!(undo_len(&s), undo);
}
/// Image info gives a distorted image's resolution at its middle, not the resolution it had
/// before the distort.
#[test]
fn image_info_measures_a_distorted_image_at_its_middle() {
let mut s = session();
placed_image(&mut s);
// 2 pixels across 100 pt: 1.44 ppi.
let ppi = |s: &mut Session| {
let out = s.execute("image.info", &json!({})).unwrap();
[out["ppi"][0].as_f64().unwrap(), out["ppi"][1].as_f64().unwrap()]
};
assert!((ppi(&mut s)[0] - 1.44).abs() < 1e-9);
// The top squeezed to half the width: the middle of the pixels spans less than 100 pt across,
// so the resolution across there is higher.
s.execute("object.distort", &json!({ "corners": [[25, 0], [75, 0], [100, 100], [0, 100]] })).unwrap();
let [x, _] = ppi(&mut s);
assert!(x > 1.44 * 1.1, "{x}");
}
/// Rasterize draws a distorted image's pixels between its corners, and the image it makes is a
/// plain one.
#[test]
fn rasterize_draws_a_distorted_image_between_its_corners() {
let mut s = session();
let img = placed_image(&mut s);
let mut png = std::io::Cursor::new(vec![]);
image::RgbaImage::from_pixel(2, 2, image::Rgba([255, 0, 0, 255])).write_to(&mut png, image::ImageFormat::Png).unwrap();
s.edit("Pixels", |d, _| {
d.images.insert("pic".into(), vectorcraft_doc::ImageBlob::png(png.into_inner()));
Ok(())
})
.unwrap();
s.execute("object.distort", &json!({ "corners": [[40, 0], [60, 0], [100, 100], [0, 100]] })).unwrap();
s.execute("select.set", &json!({ "ids": [img.0] })).unwrap();
let out = s.execute("object.rasterize", &json!({ "ppi": 72, "background": "transparent", "addAround": 0 })).unwrap();
let d = &s.doc().unwrap().doc;
let id = NodeId(out["id"].as_u64().unwrap());
let n = d.node(id).unwrap();
assert!(!n.is_distorted_image());
let vectorcraft_doc::NodeKind::Image(im) = &n.kind else { panic!("an image") };
// The raster covers the corners' bounds.
let b = n.geometric_bounds().unwrap();
assert!([b.x0, b.y0, b.x1 - 100.0, b.y1 - 100.0].iter().all(|v| v.abs() <= 1.0), "{b:?}");
let px = craft_image_codecs::decode(&d.images[&im.key].bytes).unwrap();
let (w, h) = px.dimensions();
let rgba = px.to_rgba8();
let alpha = |x: f64, y: f64| {
let p = im.xf.inverse() * Point::new(x, y);
assert!(p.x >= 0.0 && p.y >= 0.0 && p.x < f64::from(w) && p.y < f64::from(h), "({x}, {y}) is outside the raster: {p:?}");
let (i, j) = (p.x as u32, p.y as u32);
rgba[((j * w + i) * 4 + 3) as usize]
};
assert_eq!(alpha(50.0, 90.0), 255, "inside the corners");
assert_eq!(alpha(10.0, 10.0), 0, "inside the old rectangle, outside the corners");
}
/// A Free Transform drag in Free Distort mode on an image puts the dragged corner where the drag
/// ends, in one undo step, also when a position on the way would have folded the image.
#[test]
fn free_transform_distort_drag_on_an_image_is_one_undo_step() {
let mut s = session();
let img = placed_image(&mut s);
let undo = undo_len(&s);
let v = ViewInfo::default();
s.select_tool("freeTransform", v).unwrap();
s.set_tool_option("mode", &json!("distort"));
s.pointer(&PointerEvent::new(PointerKind::Down, 100.0, 100.0), v).unwrap();
// Past the top left corner: the image would fold over.
s.pointer(&PointerEvent::new(PointerKind::Drag, -50.0, -50.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Drag, 130.0, 120.0), v).unwrap();
s.pointer(&PointerEvent::new(PointerKind::Up, 130.0, 120.0), v).unwrap();
assert_corners(corners(&s, img), [(0.0, 0.0), (100.0, 0.0), (130.0, 120.0), (0.0, 100.0)]);
assert!(s.doc().unwrap().doc.node(img).unwrap().is_distorted_image());
assert_eq!(undo_len(&s), undo + 1);
}
#[test]
fn free_transform_distort_mode_via_pointer() {
let mut s = session();
+66 -7
View File
@@ -298,6 +298,10 @@ impl Session {
let points = self.tool.options().get("meshPoints").cloned().unwrap_or_else(|| Value::Array(vec![]));
lent.set_option("meshPoints", &points);
}
// The Cmd/Ctrl held for the loan is not the Cmd/Ctrl that mirrors a dragged handle (#7842).
if id == "directSelection" {
lent.set_option("lentByCmd", &Value::Bool(true));
}
self.selection_at_lend = self.active().map(|d| (d.uid, d.selection.clone()));
self.lender = Some(std::mem::replace(&mut self.tool, lent));
Ok((PointerEvent { mods: Mods { cmd: false, ..ev.mods }, ..*ev }, settled))
@@ -611,13 +615,18 @@ impl Session {
/// Escape, as during a drag, for most tools), and a release returns the tool to rest. Of what
/// the tool asks for along the way, only a cancel and a notify run, so a marquee selects
/// nothing and a click opens no size dialog. The tool gets back the persistent options it had
/// when the press began, and none of the press's changes to them are stored. A dropped Type
/// press restores the prior selection. The freeform gradient point selected once the tool
/// took the press is selected again. A press held while the tool computes an edit on another
/// thread has not reached the tool: it is removed from the held input with the pointer events
/// and tool keys held after it, and the tool is left as it is. A perspective plane key held
/// after it stays held, since the plane it picks outlasts a dropped press. Pointer events held
/// after the last held release belong to the press the tool has, and are removed with it.
/// when the press began, and none of the press's changes to them are stored. An option set
/// during the press with [`Self::set_tool_option`] or [`Self::set_tool_options`], or a General ›
/// Corner Radius change during a Rounded Rectangle press, keeps its new value, also when the
/// tool lent a selection tool for the press (a Cmd-drag). Setting an option stores all of the
/// tool's options, the press's changes included, so the dropped press then stores the options
/// it puts back. A dropped Type press restores the prior selection. The freeform gradient
/// point selected once the tool took the press is selected again. A press held while the tool
/// computes an edit on another thread has not reached the tool: it is removed from the held
/// input with the pointer events and tool keys held after it, and the tool is left as it is.
/// A perspective plane key held after it stays held, since the plane it picks outlasts a
/// dropped press. Pointer events held after the last held release belong to the press the tool
/// has, and are removed with it.
pub fn drop_tool_press(&mut self, view: ViewInfo) -> Result<()> {
let (from, held) = self.held_press();
let keep: Vec<bool> = (self.held_input.iter().enumerate())
@@ -635,6 +644,7 @@ impl Session {
// Nothing to roll back without a document; the tool still drops the press and gets the release.
let _ = self.cancel_interaction();
let before = self.press_options.take();
let stored = std::mem::take(&mut self.press_options_stored);
let type_selection = self.press_type_selection.take();
let point = self.press_point.take();
let mut acts = self.with_tool_cx(view, |t, cx| t.drop_press(cx));
@@ -669,6 +679,11 @@ impl Session {
self.tool.set_option(k, v);
}
}
// An option set during the press stored every option the tool had then, the press's
// changes included: those stored values are put back too.
if stored {
self.keep_tool_settings();
}
}
r.map(drop)
}
@@ -706,6 +721,7 @@ impl Session {
match ev.kind {
PointerKind::Down => {
self.press_options = Some((self.tool.id().to_string(), Self::persistent_options(self.tool.as_ref())));
self.press_options_stored = false;
self.press_type_selection =
if matches!(self.tool.id(), "type" | "areaType" | "typeOnPath" | "verticalType" | "verticalAreaType" | "verticalTypeOnPath") {
self.active().map(|st| (st.selection.clone(), st.active_layer))
@@ -715,6 +731,7 @@ impl Session {
}
PointerKind::Up => {
self.press_options = None;
self.press_options_stored = false;
self.press_type_selection = None;
}
_ => {}
@@ -1309,9 +1326,12 @@ impl Session {
if key == "queue" && self.tool.id() == "place" {
self.note_place_queue_roots();
}
let before_press = self.options_before_press_set();
let sets_pressed = self.press_taken_by(self.tool.id());
self.tool.set_option(key, v);
self.tool_set_since_reset = true;
self.keep_tool_settings();
self.keep_press_set(before_press, |k| sets_pressed && k == key, sets_pressed);
}
/// Keep the automation roots in force now as those the place cursor's queue, being loaded,
@@ -1356,6 +1376,8 @@ impl Session {
self.note_place_queue_roots();
}
let active = id.is_none_or(|id| id == self.tool.id());
let before_press = self.options_before_press_set();
let sets_pressed = self.press_taken_by(id.unwrap_or(self.tool.id()));
// The tool that lent a selection tool for a Cmd-drag is the tool chosen, and active again
// when the drag ends.
let lender = id.is_some_and(|id| self.lender.as_deref().is_some_and(|l| l.id() == id));
@@ -1393,9 +1415,46 @@ impl Session {
let set = other.id();
Self::restore_stores(&self.prefs, self.tool.as_mut(), |store| settings::stores(set).any(|(s, _)| s == store));
}
self.keep_press_set(before_press, |k| sets_pressed && values.contains_key(k), sets_pressed);
out
}
/// The tool that took the press under way: the active tool, or the tool that lent a selection
/// tool for it (a Cmd-drag), which the dropped press gives its options back to.
fn pressed_tool(&self) -> Option<&dyn Tool> {
let (pressed, _) = self.press_options.as_ref()?;
std::iter::once(&self.tool).chain(self.lender.as_ref()).map(|t| t.as_ref()).find(|t| t.id() == pressed)
}
/// Tool `id` took the press under way ([`Self::pressed_tool`]).
pub(crate) fn press_taken_by(&self, id: &str) -> bool {
self.pressed_tool().is_some_and(|t| t.id() == id)
}
/// The persistent options of the tool that took the press under way ([`Self::pressed_tool`])
/// before an option is set: a dropped press puts back the options it began with, except those
/// the set changes ([`Self::keep_press_set`]).
fn options_before_press_set(&self) -> Option<Map<String, Value>> {
self.pressed_tool().map(Self::persistent_options)
}
/// After an option is set during a held press, the press's saved options take the options of
/// the tool that took the press that the set changed from `before` or named (`named`), so a
/// dropped press keeps them. `stored`: the set stored that tool's options, the press's changes
/// included, so a dropped press stores the options it puts back.
fn keep_press_set(&mut self, before: Option<Map<String, Value>>, named: impl Fn(&str) -> bool, stored: bool) {
let Some(before) = before else { return };
let Some(now) = self.pressed_tool().map(Self::persistent_options) else { return };
self.press_options_stored |= stored;
if let Some((_, saved)) = self.press_options.as_mut() {
for (k, v) in now {
if before.get(&k) != Some(&v) || named(&k) {
saved.insert(k, v);
}
}
}
}
/// `tool.setOption {tool?, key?, value?, values?}` (a command of the desktop app and of the
/// headless host): set one option (`key`, `value`) or several (`values`) of `tool` (default:
/// the tool active when the call arrives, named before the edit in progress is finished) → its
+630
View File
@@ -0,0 +1,630 @@
//! Temporary Cmd/Control symmetry while Direct Selection drags an existing handle.
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use serde_json::{Value, json};
use vectorcraft_doc::{Node, NodeId};
use vectorcraft_engine::{Session, ViewInfo};
use vectorcraft_geom::{Anchor, AnchorKind, Point};
use vectorcraft_tools::{Mods, PointerEvent, PointerKind};
fn run(s: &mut Session, command: &str, params: Value) -> Value {
s.execute(command, &params).unwrap()
}
fn view() -> ViewInfo {
ViewInfo {
smart_guides: false,
guides: false,
snap_to_point: false,
snap_to_grid: false,
snap_to_pixel: false,
snap_to_glyph: false,
corner_widgets: false,
show_bbox: false,
..ViewInfo::default()
}
}
fn session() -> Session {
let mut s = Session::new();
run(&mut s, "file.new", json!({"width": 900, "height": 700}));
for (key, value) in [("constrainAngle", json!(0)), ("showHandlesMultipleAnchors", json!(true)), ("realTimeDrawing", json!(true))] {
run(&mut s, "prefs.set", json!({"key": key, "value": value}));
}
s
}
fn node(s: &Session, id: NodeId) -> Node {
s.doc().unwrap().doc.node(id).unwrap().clone()
}
fn curve(s: &mut Session, incoming: Point) -> NodeId {
let id = run(
s,
"path.create",
json!({"anchors": [
{"x": 20, "y": 220},
{"x": 100, "y": 100, "in": [incoming.x, incoming.y], "out": [180, 100]},
{"x": 320, "y": 220}
]}),
);
let id = NodeId(id["id"].as_u64().unwrap());
s.select_tool("directSelection", view()).unwrap();
id
}
fn anchor(s: &Session, id: NodeId) -> Anchor {
node(s, id).path_data().unwrap().subpaths[0].anchors[1]
}
fn pointer(s: &mut Session, kind: PointerKind, at: Point, mods: Mods) {
s.pointer(&PointerEvent::new(kind, at.x, at.y).with_mods(mods), view()).unwrap();
}
fn press_handle(s: &mut Session, at: Point) {
pointer(s, PointerKind::Down, at, Mods::default());
assert_eq!(s.tool_id(), "directSelection");
assert!(s.in_interaction(), "the visible handle press begins Reshape");
}
fn near(actual: Point, expected: Point) {
assert!(actual.distance(expected) < 1e-6, "point {actual:?}, expected {expected:?}");
}
fn handles(a: Anchor, incoming: Point, outgoing: Point, kind: AnchorKind) {
near(a.h_in, incoming);
near(a.h_out, outgoing);
assert_eq!(a.kind, kind);
}
fn assert_other_geometry(s: &Session, id: NodeId, before: &Node) {
let after = node(s, id);
let (old, new) = (before.path_data().unwrap(), after.path_data().unwrap());
assert_eq!(new.subpaths.len(), old.subpaths.len());
assert_eq!(new.subpaths[0].closed, old.subpaths[0].closed);
assert_eq!(new.subpaths[0].anchors.len(), 3);
assert_eq!(new.subpaths[0].anchors[0], old.subpaths[0].anchors[0]);
assert_eq!(new.subpaths[0].anchors[2], old.subpaths[0].anchors[2]);
assert_eq!(new.subpaths[0].anchors[1].p, old.subpaths[0].anchors[1].p);
assert_eq!(after.appearance, before.appearance);
}
#[test]
fn direct_handle_baseline_ordinary_smooth_keeps_the_opposite_length() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
let before = node(&s, id);
assert_eq!(anchor(&s, id).kind, AnchorKind::Smooth);
let selection = json!(s.doc().unwrap().selection);
let undo = s.doc().unwrap().history.undo.len();
press_handle(&mut s, Point::new(180.0, 100.0));
let q = Point::new(180.0, 160.0);
pointer(&mut s, PointerKind::Drag, q, Mods::default());
handles(anchor(&s, id), Point::new(60.0, 70.0), q, AnchorKind::Smooth);
assert_other_geometry(&s, id, &before);
pointer(&mut s, PointerKind::Up, q, Mods::default());
assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
assert_eq!(json!(s.doc().unwrap().selection), selection);
}
#[test]
fn direct_handle_baseline_cmd_added_mid_drag_mirrors_the_opposite() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
let before = node(&s, id);
press_handle(&mut s, Point::new(180.0, 100.0));
let q = Point::new(180.0, 160.0);
pointer(&mut s, PointerKind::Drag, q, Mods::default());
handles(anchor(&s, id), Point::new(60.0, 70.0), q, AnchorKind::Smooth);
pointer(&mut s, PointerKind::Drag, q, Mods { cmd: true, ..Mods::default() });
handles(anchor(&s, id), Point::new(20.0, 40.0), q, AnchorKind::Smooth);
assert_other_geometry(&s, id, &before);
pointer(&mut s, PointerKind::Up, q, Mods { cmd: true, ..Mods::default() });
}
#[test]
fn direct_handle_cmd_mirror_holds_through_a_space_translation() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
press_handle(&mut s, Point::new(180.0, 100.0));
let q = Point::new(180.0, 160.0);
pointer(&mut s, PointerKind::Drag, q, cmd());
handles(anchor(&s, id), Point::new(20.0, 40.0), q, AnchorKind::Smooth);
// Space moves the anchor and both handles; the opposite handle stays mirrored.
let moved = Point::new(200.0, 190.0);
pointer(&mut s, PointerKind::Drag, moved, Mods { space: true, ..cmd() });
let a = anchor(&s, id);
near(a.p, Point::new(120.0, 130.0));
handles(a, Point::new(40.0, 70.0), Point::new(200.0, 190.0), AnchorKind::Smooth);
// Releasing Space without moving keeps the translated, mirrored handles.
pointer(&mut s, PointerKind::Drag, moved, cmd());
handles(anchor(&s, id), Point::new(40.0, 70.0), Point::new(200.0, 190.0), AnchorKind::Smooth);
let next = Point::new(220.0, 190.0);
pointer(&mut s, PointerKind::Drag, next, cmd());
assert_mirrored(anchor(&s, id), next, AnchorKind::Smooth);
pointer(&mut s, PointerKind::Up, next, cmd());
}
#[test]
fn direct_handle_modifiers_changed_during_a_space_translation_apply_at_once() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
press_handle(&mut s, Point::new(180.0, 100.0));
pointer(&mut s, PointerKind::Drag, Point::new(180.0, 160.0), cmd());
let moved = Point::new(200.0, 190.0);
pointer(&mut s, PointerKind::Drag, moved, Mods { space: true, ..cmd() });
handles(anchor(&s, id), Point::new(40.0, 70.0), moved, AnchorKind::Smooth);
// Releasing Cmd while Space is held gives the opposite handle its own length again.
pointer(&mut s, PointerKind::Drag, moved, Mods { space: true, ..Mods::default() });
let a = anchor(&s, id);
near(a.p, Point::new(120.0, 130.0));
handles(a, Point::new(80.0, 100.0), moved, AnchorKind::Smooth);
// Alt while Space is held leaves the opposite handle where the translation put it.
pointer(&mut s, PointerKind::Drag, moved, Mods { space: true, alt: true, ..cmd() });
handles(anchor(&s, id), Point::new(70.0, 130.0), moved, AnchorKind::Corner);
pointer(&mut s, PointerKind::Up, moved, Mods { alt: true, ..cmd() });
}
#[derive(Debug, PartialEq)]
struct Snapshot {
document: Value,
selection: Value,
undo: usize,
redo: usize,
}
fn snapshot(s: &Session) -> Snapshot {
let st = s.doc().unwrap();
Snapshot { document: json!(st.doc), selection: json!(st.selection), undo: st.history.undo.len(), redo: st.history.redo.len() }
}
fn assert_content(s: &Session, expected: &Snapshot) {
let got = snapshot(s);
assert_eq!(got.document, expected.document);
assert_eq!(got.selection, expected.selection);
}
fn cmd() -> Mods {
Mods { cmd: true, ..Mods::default() }
}
fn reflected(a: Point, q: Point) -> Point {
a - (q - a)
}
fn constrained(a: Point, q: Point) -> Point {
a + vectorcraft_geom::constrain_angle_from(q - a, 45.0, 0.0)
}
fn assert_mirrored(a: Anchor, q: Point, kind: AnchorKind) {
handles(a, reflected(a.p, q), q, kind);
}
#[test]
fn direct_handle_stationary_cmd_release_repress_commit_and_next_gesture() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
let before = snapshot(&s);
press_handle(&mut s, Point::new(180.0, 100.0));
let q = Point::new(180.0, 160.0);
for (mods, opposite) in [(cmd(), Point::new(20.0, 40.0)), (Mods::default(), Point::new(60.0, 70.0)), (cmd(), Point::new(20.0, 40.0))] {
pointer(&mut s, PointerKind::Drag, q, mods);
handles(anchor(&s, id), opposite, q, AnchorKind::Smooth);
assert_eq!(s.doc().unwrap().history.undo.len(), before.undo, "previews are not separate edits");
}
pointer(&mut s, PointerKind::Up, q, cmd());
let committed = snapshot(&s);
assert_eq!(committed.undo, before.undo + 1);
assert_eq!(committed.selection, before.selection);
run(&mut s, "edit.undo", json!({}));
assert_content(&s, &before);
run(&mut s, "edit.redo", json!({}));
assert_content(&s, &committed);
// Cmd did not install a persistent coupling mode: a later ordinary Smooth drag keeps
// the opposite handle's committed length, rather than matching the newly dragged length.
press_handle(&mut s, q);
let next = Point::new(180.0, 200.0);
pointer(&mut s, PointerKind::Drag, next, Mods::default());
let a = anchor(&s, id);
near(a.h_out, next);
assert_eq!(a.kind, AnchorKind::Smooth);
assert!((a.h_in.distance(a.p) - 100.0).abs() < 1e-6);
assert!((a.h_in.distance(a.p) - a.h_out.distance(a.p)).abs() > 20.0);
assert!(((a.h_in - a.p).cross(a.h_out - a.p)).abs() < 1e-6);
pointer(&mut s, PointerKind::Up, next, Mods::default());
assert_eq!(s.doc().unwrap().history.undo.len(), before.undo + 2);
}
#[test]
fn direct_handle_shift_constrains_before_mirroring_and_alt_takes_priority() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
let p = anchor(&s, id).p;
press_handle(&mut s, Point::new(180.0, 100.0));
let raw = Point::new(180.0, 150.0);
let q = constrained(p, raw);
let shifted = Mods { shift: true, ..cmd() };
pointer(&mut s, PointerKind::Drag, raw, shifted);
assert_mirrored(anchor(&s, id), q, AnchorKind::Smooth);
pointer(&mut s, PointerKind::Drag, raw, Mods { alt: true, ..shifted });
handles(anchor(&s, id), Point::new(50.0, 100.0), q, AnchorKind::Corner);
// Removing Alt rebuilds from the original Smooth anchor, not the Corner preview.
pointer(&mut s, PointerKind::Drag, raw, shifted);
assert_mirrored(anchor(&s, id), q, AnchorKind::Smooth);
pointer(&mut s, PointerKind::Drag, raw, Mods { alt: true, ..cmd() });
handles(anchor(&s, id), Point::new(50.0, 100.0), raw, AnchorKind::Corner);
pointer(&mut s, PointerKind::Up, raw, Mods { alt: true, ..cmd() });
}
#[test]
fn direct_handle_corner_with_collapsed_partner_is_reversible_without_changing_kind() {
let mut s = session();
let id = curve(&mut s, Point::new(100.0, 100.0));
let before = snapshot(&s);
assert_eq!(anchor(&s, id).kind, AnchorKind::Corner);
press_handle(&mut s, Point::new(180.0, 100.0));
let q = Point::new(180.0, 160.0);
pointer(&mut s, PointerKind::Drag, q, cmd());
assert_mirrored(anchor(&s, id), q, AnchorKind::Corner);
pointer(&mut s, PointerKind::Drag, q, Mods::default());
handles(anchor(&s, id), Point::new(100.0, 100.0), q, AnchorKind::Corner);
pointer(&mut s, PointerKind::Drag, q, cmd());
assert_mirrored(anchor(&s, id), q, AnchorKind::Corner);
s.tool_key(vectorcraft_tools::ToolKey::Escape, Mods::default(), view()).unwrap();
assert_eq!(snapshot(&s), before);
}
#[test]
fn direct_handle_stationary_drag_still_mirrors_unequal_partner_but_equal_is_noop() {
for (incoming, changes) in [(Point::new(50.0, 100.0), true), (Point::new(20.0, 100.0), false)] {
let mut s = session();
let id = curve(&mut s, incoming);
let before = snapshot(&s);
let q = Point::new(180.0, 100.0);
press_handle(&mut s, q);
pointer(&mut s, PointerKind::Drag, q, cmd());
assert_mirrored(anchor(&s, id), q, AnchorKind::Smooth);
pointer(&mut s, PointerKind::Up, q, cmd());
if changes {
assert_eq!(s.doc().unwrap().history.undo.len(), before.undo + 1);
run(&mut s, "edit.undo", json!({}));
assert_content(&s, &before);
} else {
assert_eq!(snapshot(&s), before, "an already reflected pair records no edit");
}
}
}
#[test]
fn direct_handle_escape_restores_document_selection_and_existing_redo() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
run(&mut s, "shape.rectangle", json!({"x": 500, "y": 400, "width": 25, "height": 30}));
let redo_document = snapshot(&s).document;
run(&mut s, "edit.undo", json!({}));
run(&mut s, "select.set", json!({"ids": [id.0]}));
let before = snapshot(&s);
assert_eq!(before.redo, 1, "a real existing Redo is the cancellation control");
press_handle(&mut s, Point::new(180.0, 100.0));
let q = Point::new(180.0, 160.0);
pointer(&mut s, PointerKind::Drag, q, cmd());
assert_mirrored(anchor(&s, id), q, AnchorKind::Smooth);
s.tool_key(vectorcraft_tools::ToolKey::Escape, Mods::default(), view()).unwrap();
assert!(!s.in_interaction());
assert_eq!(snapshot(&s), before);
pointer(&mut s, PointerKind::Up, q, Mods::default());
assert_eq!(snapshot(&s), before, "a later release does not commit the canceled preview");
run(&mut s, "edit.redo", json!({}));
assert_eq!(snapshot(&s).document, redo_document, "the prior Redo still restores its actual content");
}
#[test]
fn direct_handle_cmd_before_press_still_lends_selection_and_returns_direct() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
let before = snapshot(&s);
let a = anchor(&s, id);
pointer(&mut s, PointerKind::Down, a.p, cmd());
assert_eq!(s.tool_id(), "selection", "Cmd before Down keeps the existing Selection loan");
pointer(&mut s, PointerKind::Up, a.p, cmd());
assert_eq!(s.tool_id(), "directSelection");
assert_eq!(anchor(&s, id), a);
assert_eq!(snapshot(&s).document, before.document);
assert_eq!(s.doc().unwrap().history.undo.len(), before.undo);
}
#[test]
fn direct_handle_cmd_that_lends_direct_selection_from_the_pen_does_not_mirror() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
s.select_tool("pen", view()).unwrap();
let before = node(&s, id);
let undo = s.doc().unwrap().history.undo.len();
pointer(&mut s, PointerKind::Down, Point::new(180.0, 100.0), cmd());
assert_eq!(s.tool_id(), "directSelection", "Cmd lends the Pen the last selection tool");
let q = Point::new(180.0, 160.0);
pointer(&mut s, PointerKind::Drag, q, cmd());
handles(anchor(&s, id), Point::new(60.0, 70.0), q, AnchorKind::Smooth);
// Cmd let go and pressed again during the drag mirrors, as it does in Direct Selection itself.
pointer(&mut s, PointerKind::Drag, q, Mods::default());
handles(anchor(&s, id), Point::new(60.0, 70.0), q, AnchorKind::Smooth);
pointer(&mut s, PointerKind::Drag, q, cmd());
handles(anchor(&s, id), Point::new(20.0, 40.0), q, AnchorKind::Smooth);
assert_other_geometry(&s, id, &before);
pointer(&mut s, PointerKind::Up, q, cmd());
assert_eq!(s.tool_id(), "pen");
assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
}
#[test]
fn direct_handle_cmd_held_through_a_pen_lent_drag_leaves_the_opposite_length() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
s.select_tool("pen", view()).unwrap();
pointer(&mut s, PointerKind::Down, Point::new(180.0, 100.0), cmd());
let q = Point::new(180.0, 160.0);
pointer(&mut s, PointerKind::Drag, q, cmd());
pointer(&mut s, PointerKind::Up, q, cmd());
assert_eq!(s.tool_id(), "pen");
handles(anchor(&s, id), Point::new(60.0, 70.0), q, AnchorKind::Smooth);
}
fn text_anchor(s: &Session, id: NodeId) -> Anchor {
let n = node(s, id);
let vectorcraft_doc::NodeKind::Text(t) = n.kind else { panic!("text on a path") };
t.type_path().unwrap().subpaths[0].anchors[1]
}
fn text_properties(s: &Session, id: NodeId) -> Value {
let n = node(s, id);
let vectorcraft_doc::NodeKind::Text(t) = n.kind else { panic!("text on a path") };
let vectorcraft_doc::TextKind::OnPath { start, end, .. } = &t.kind else { panic!("path text") };
json!({"runs": t.runs, "para": t.para, "paras": t.paras, "xf": t.xf, "start": start, "end": end,
"effect": t.path_effect, "align": t.path_align, "spacing": t.path_spacing, "appearance": n.appearance})
}
fn path_text(s: &mut Session) -> NodeId {
let path = curve(s, Point::new(50.0, 100.0));
let made = run(
s,
"text.createInPath",
json!({"path": path.0, "mode": "onPath", "text": "Along the original curve", "font": "Source Sans 3", "size": 12}),
);
let id = NodeId(made["id"].as_u64().unwrap());
run(s, "type.pathOptions", json!({"id": id.0, "start": 0.15, "end": 0.85}));
run(s, "object.transform", json!({"ids": [id.0], "matrix": [1.5, 0.4, 0.25, 0.9, 250, 80]}));
s.select_tool("directSelection", view()).unwrap();
id
}
#[test]
fn direct_handle_affine_path_text_mirrors_in_drawn_space_and_keeps_brackets() {
let mut s = session();
let id = path_text(&mut s);
let before = snapshot(&s);
let properties = text_properties(&s, id);
assert_eq!(properties["start"], json!(0.15));
assert_eq!(properties["end"], json!(0.85));
let a = text_anchor(&s, id);
assert_eq!(a.kind, AnchorKind::Smooth);
near(a.p, Point::new(425.0, 210.0));
near(a.h_out, Point::new(545.0, 242.0));
assert!((a.h_in.distance(a.p) - a.h_out.distance(a.p)).abs() > 40.0);
press_handle(&mut s, a.h_out);
let raw = a.p + vectorcraft_geom::Vec2::new(80.0, 60.0);
pointer(&mut s, PointerKind::Drag, raw, cmd());
assert_mirrored(text_anchor(&s, id), raw, AnchorKind::Smooth);
assert_eq!(text_properties(&s, id), properties);
let shifted = Mods { shift: true, ..cmd() };
pointer(&mut s, PointerKind::Drag, raw, shifted);
assert_mirrored(text_anchor(&s, id), constrained(a.p, raw), AnchorKind::Smooth);
assert_eq!(text_properties(&s, id), properties);
pointer(&mut s, PointerKind::Up, raw, shifted);
let after = snapshot(&s);
assert_eq!(after.undo, before.undo + 1);
run(&mut s, "edit.undo", json!({}));
assert_content(&s, &before);
run(&mut s, "edit.redo", json!({}));
assert_content(&s, &after);
}
fn blend_state(s: &Session, id: NodeId) -> (Anchor, Value, Vec<u32>) {
let n = node(s, id);
let vectorcraft_doc::NodeKind::Blend { children, spec } = n.kind else { panic!("blend") };
assert!(spec.spine.is_some(), "the fixture uses an already pinned spine");
let path = vectorcraft_doc::live::blend_spine(&children, &spec).unwrap().0;
(path.subpaths[0].anchors[1], json!(children), spec.key_anchors.clone())
}
fn blend(s: &mut Session) -> NodeId {
let a = run(s, "shape.rectangle", json!({"x": 15, "y": 95, "width": 10, "height": 10}))["id"].as_u64().unwrap();
let b = run(s, "shape.rectangle", json!({"x": 295, "y": 95, "width": 10, "height": 10}))["id"].as_u64().unwrap();
let made = run(s, "object.blend.make", json!({"ids": [a, b], "steps": 2}));
let id = NodeId(made["id"].as_u64().unwrap());
let added = run(s, "object.blend.spine.addAnchor", json!({"id": id.0, "x": 100, "y": 100}));
assert_eq!(added["anchor"], json!(1));
run(s, "object.blend.spine.convertAnchor", json!({"id": id.0, "anchor": 1, "to": "smooth", "x": 180, "y": 100}));
run(s, "object.blend.spine.moveAnchor", json!({"id": id.0, "anchor": 1, "handle": "in", "x": 50, "y": 100}));
run(s, "select.set", json!({"ids": [id.0]}));
s.select_tool("directSelection", view()).unwrap();
let (middle, _, keys) = blend_state(s, id);
near(middle.p, Point::new(100.0, 100.0));
handles(middle, Point::new(50.0, 100.0), Point::new(180.0, 100.0), AnchorKind::Smooth);
assert_eq!(keys, [0, 2]);
// An actual spine-point click makes its handles visible to Direct Selection.
pointer(s, PointerKind::Down, middle.p, Mods::default());
pointer(s, PointerKind::Up, middle.p, Mods::default());
assert!(!s.in_interaction());
id
}
#[test]
fn direct_handle_pinned_blend_spine_cmd_shift_preserves_keys_and_mapping() {
let mut s = session();
let id = blend(&mut s);
let before = snapshot(&s);
let (a, keys, mapping) = blend_state(&s, id);
press_handle(&mut s, a.h_out);
let q = Point::new(180.0, 160.0);
pointer(&mut s, PointerKind::Drag, q, cmd());
assert_mirrored(blend_state(&s, id).0, q, AnchorKind::Smooth);
let raw = Point::new(180.0, 150.0);
let shifted = Mods { shift: true, ..cmd() };
pointer(&mut s, PointerKind::Drag, raw, shifted);
assert_mirrored(blend_state(&s, id).0, constrained(a.p, raw), AnchorKind::Smooth);
// The existing spine Shift-only path is deliberately unconstrained; Cmd's new rule
// must not leak into that old branch after the modifier is released.
pointer(&mut s, PointerKind::Drag, raw, Mods { shift: true, ..Mods::default() });
near(blend_state(&s, id).0.h_out, raw);
pointer(&mut s, PointerKind::Drag, raw, shifted);
let (after_anchor, after_keys, after_mapping) = blend_state(&s, id);
assert_mirrored(after_anchor, constrained(a.p, raw), AnchorKind::Smooth);
assert_eq!(after_keys, keys, "handle edits leave the actual key art unchanged");
assert_eq!(after_mapping, mapping);
pointer(&mut s, PointerKind::Up, raw, shifted);
let after = snapshot(&s);
assert_eq!(after.undo, before.undo + 1);
assert_eq!(after.selection, before.selection);
run(&mut s, "edit.undo", json!({}));
assert_content(&s, &before);
run(&mut s, "edit.redo", json!({}));
assert_content(&s, &after);
}
#[test]
fn direct_handle_incoming_drag_mirrors_outgoing_and_release_restores_ordinary_length() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
let before = snapshot(&s);
let original = node(&s, id);
press_handle(&mut s, Point::new(50.0, 100.0));
let q = Point::new(40.0, 20.0);
pointer(&mut s, PointerKind::Drag, q, Mods::default());
handles(anchor(&s, id), q, Point::new(148.0, 164.0), AnchorKind::Smooth);
pointer(&mut s, PointerKind::Drag, q, cmd());
handles(anchor(&s, id), q, Point::new(160.0, 180.0), AnchorKind::Smooth);
pointer(&mut s, PointerKind::Drag, q, Mods::default());
handles(anchor(&s, id), q, Point::new(148.0, 164.0), AnchorKind::Smooth);
pointer(&mut s, PointerKind::Drag, q, cmd());
assert_other_geometry(&s, id, &original);
pointer(&mut s, PointerKind::Up, q, cmd());
handles(anchor(&s, id), q, Point::new(160.0, 180.0), AnchorKind::Smooth);
assert_eq!(s.doc().unwrap().history.undo.len(), before.undo + 1);
assert_eq!(snapshot(&s).selection, before.selection);
run(&mut s, "edit.undo", json!({}));
assert_content(&s, &before);
}
/// `command` with `params` is refused with an error containing `message`, and the document,
/// selection and undo history stay as they were.
fn refused(s: &mut Session, command: &str, params: Value, message: &str) {
let before = snapshot(s);
let err = s.execute(command, &params).unwrap_err().to_string();
assert!(err.contains(message), "{command} {params}: {err}");
assert_eq!(snapshot(s), before);
}
#[test]
fn path_set_handle_symmetric_mirrors_refuses_bad_values_and_records_no_step_when_in_place() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
let at = |x: f64, y: f64| json!({"id": id.0, "anchor": 1, "which": "out", "x": x, "y": y});
for bad in [json!("yes"), json!(1)] {
let mut p = at(180.0, 160.0);
p["symmetric"] = bad;
refused(&mut s, "path.setHandle", p, "`symmetric` must be true or false");
}
let mut both = at(180.0, 160.0);
both["symmetric"] = json!(true);
both["independent"] = json!(true);
refused(&mut s, "path.setHandle", both, "`independent` and `symmetric` cannot both be true");
let undo = s.doc().unwrap().history.undo.len();
let mut mirror = at(180.0, 160.0);
mirror["symmetric"] = json!(true);
run(&mut s, "path.setHandle", mirror.clone());
handles(anchor(&s, id), Point::new(20.0, 40.0), Point::new(180.0, 160.0), AnchorKind::Smooth);
assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
let placed = snapshot(&s);
run(&mut s, "path.setHandle", mirror);
assert_eq!(snapshot(&s), placed, "both handles already in place record no undo step");
}
#[test]
fn symmetric_leaves_the_other_handle_retracted_at_an_open_end() {
let mut s = session();
let id = curve(&mut s, Point::new(50.0, 100.0));
let first = |s: &Session| node(s, id).path_data().unwrap().subpaths[0].anchors[0];
let p = first(&s).p;
run(&mut s, "path.setHandle", json!({"id": id.0, "anchor": 0, "which": "out", "x": 60, "y": 180, "symmetric": true}));
handles(first(&s), p, Point::new(60.0, 180.0), AnchorKind::Corner);
let mut s = session();
let blend_id = blend(&mut s);
let end = |s: &Session| {
let n = node(s, blend_id);
let vectorcraft_doc::NodeKind::Blend { children, spec } = n.kind else { panic!("blend") };
vectorcraft_doc::live::blend_spine(&children, &spec).unwrap().0.subpaths[0].anchors[0]
};
let start = end(&s);
run(&mut s, "object.blend.spine.moveAnchor", json!({"id": blend_id.0, "anchor": 0, "handle": "out", "x": 60, "y": 60, "symmetric": true}));
near(end(&s).h_out, Point::new(60.0, 60.0));
near(end(&s).h_in, start.h_in);
near(end(&s).h_in, start.p);
}
#[test]
fn spine_and_type_path_handles_refuse_bad_symmetric_values() {
let mut s = session();
let id = blend(&mut s);
let spine = |extra: Value| {
let mut p = json!({"id": id.0, "anchor": 1, "handle": "out", "x": 180, "y": 160});
p.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
p
};
refused(&mut s, "object.blend.spine.moveAnchor", spine(json!({"symmetric": "yes"})), "`symmetric` must be true or false");
refused(
&mut s,
"object.blend.spine.moveAnchor",
spine(json!({"symmetric": true, "independent": true})),
"`independent` and `symmetric` cannot both be true",
);
refused(
&mut s,
"object.blend.spine.moveAnchor",
json!({"id": id.0, "anchor": 1, "x": 180, "y": 160, "symmetric": true}),
"`symmetric` places a handle",
);
let text = path_text(&mut s);
let a = text_anchor(&s, text);
let at = json!({"id": text.0, "anchor": 1, "which": "out", "x": a.h_out.x, "y": a.h_out.y + 20.0});
let mut bad = at.clone();
bad["symmetric"] = json!(0);
refused(&mut s, "text.setPathHandle", bad, "`symmetric` must be true or false");
let mut both = at;
both["symmetric"] = json!(true);
both["independent"] = json!(true);
refused(&mut s, "text.setPathHandle", both, "`independent` and `symmetric` cannot both be true");
}
#[test]
fn direct_handle_cmd_that_lends_direct_selection_from_the_pen_does_not_mirror_type_on_a_path() {
let mut s = session();
let id = path_text(&mut s);
let a = text_anchor(&s, id);
let length = a.h_in.distance(a.p);
s.select_tool("pen", view()).unwrap();
pointer(&mut s, PointerKind::Down, a.h_out, cmd());
assert_eq!(s.tool_id(), "directSelection");
let q = a.p + vectorcraft_geom::Vec2::new(80.0, 60.0);
pointer(&mut s, PointerKind::Drag, q, cmd());
let held = text_anchor(&s, id);
near(held.h_out, q);
assert!((held.h_in.distance(held.p) - length).abs() < 1e-6, "the other handle keeps its length");
pointer(&mut s, PointerKind::Drag, q, Mods::default());
pointer(&mut s, PointerKind::Drag, q, cmd());
assert_mirrored(text_anchor(&s, id), q, AnchorKind::Smooth);
pointer(&mut s, PointerKind::Up, q, cmd());
assert_eq!(s.tool_id(), "pen");
}
+8 -2
View File
@@ -118,7 +118,12 @@
//! `%AI24_EndSymbolList`); each instance as `/SymbolInstance :`, `(name) /SymbolRef ,`, the
//! matrix taking the art to art space as `a b c d tx ty /RTransformMatrix`, `;`, then its name
//! and opacity mask and a state block as a group's with its opacity and blending mode (an
//! instance with isolation, knockout or knockout shape of its own is written as its art). The
//! instance with isolation, knockout or knockout shape of its own is written as its art). A
//! dynamic symbol's art dictionary also holds `VectorCraftDynamicSymbol` (`/Int`, 1), and the
//! dictionary of an instance with changes of its own (`symbol_overrides`) holds
//! `VectorCraftSymbolOverrides`, a `/String` of the changes as hex-coded JSON: the format's own
//! entries, as other apps' editing data is not documented, read back by this reader and left out by
//! others. The
//! definitions are at most the reader's 4,096. In a symbol's art, an instance's matrix and
//! a gradient's take the art to the canvas's space turned y up about art space's origin there,
//! and a gradient mesh's corners are in that space; an envelope's contents in its dictionary are
@@ -191,7 +196,7 @@
//! and instances of
//! symbols past 4,096 as their art (symbol art past [`vectorcraft_doc::MAX_SYMBOL_NODES`] objects
//! in all left out), instances of symbols the document doesn't have as empty groups, symbols' 9-slice
//! guides, export types and dynamic type left out, gradient meshes the reader wouldn't read back as
//! guides, export types left out, gradient meshes the reader wouldn't read back as
//! they are, folded meshes, meshes in pattern tiles and in art cut to a clipping object and every mesh
//! on a large canvas as their drawn look, blends the reader wouldn't read back live as
//! their steps, other live objects (placed documents included) as their art,
@@ -220,6 +225,7 @@ use vectorcraft_pdf::PrivateData;
use crate::ps;
mod writer;
pub(crate) use writer::{DYNAMIC_KEY, OVERRIDES_KEY, hex_decode};
use writer::Writer;
+76 -2
View File
@@ -2432,6 +2432,26 @@ fn an_unpainted_paths_transparency_after_a_compound_path_is_its_own() {
assert_eq!((art[0].opacity, art[0].blend, art[1].opacity, art[1].blend), (1.0, BlendMode::Normal, 0.5, BlendMode::Multiply));
}
/// A distorted image as deep as the writer goes, in the art of 8 nested opacity masks, is written
/// as one image at the placement nearest its corners, with a warning, not left out.
#[test]
fn a_distorted_image_nested_as_deep_as_the_limit_is_written_as_its_nearest_placement() {
let mut doc = Document::new(200.0, 100.0);
let layer = doc.layers[0].id;
let mut n = image_node(&mut doc, ImageBlob::png(rgb_png()), (3, 2), Affine::translate((10.0, 10.0)) * Affine::scale(10.0), None);
n.set_image_corners([(14.0, 10.0), (36.0, 10.0), (40.0, 30.0), (10.0, 30.0)].map(|(x, y)| vectorcraft_geom::Point::new(x, y))).unwrap();
for _ in 0..8 {
let mut owner = square(&mut doc, Rect::new(10.0, 10.0, 40.0, 30.0), Color::gray(0.5));
owner.extras_mut().mask = Some(Box::new(OpacityMask::new(n, true)));
n = owner;
}
doc.insert(Some(layer), usize::MAX, n).unwrap();
let out = export_ai_editing(&doc, &opts()).unwrap();
assert!(out.warnings.iter().any(|w| w == writer::DEEP_DISTORTED), "{:?}", out.warnings);
// The samples are binary: count the `XI` lines in the bytes.
assert_eq!(out.program.windows(4).filter(|w| w == b"XI\r\n").count(), 1, "the one image");
}
/// Opacity masks in mask art nested past the limit are left out, not written empty.
#[test]
fn opacity_masks_nested_too_deep_are_left_out() {
@@ -6394,7 +6414,8 @@ fn instances_the_data_cant_hold_are_written_as_their_art() {
let layer = doc.layers[0].id;
doc.insert(Some(layer), usize::MAX, changed).unwrap();
doc.insert(Some(layer), usize::MAX, plain).unwrap();
assert_eq!(export_ai_editing(&doc, &opts()).unwrap().warnings, [writer::SYMBOL_ART, writer::SYMBOL_OPTIONS]);
doc.symbols[0].dynamic = false;
assert_eq!(export_ai_editing(&doc, &opts()).unwrap().warnings, [writer::SYMBOL_ART]);
let back = read_back(&doc);
assert_eq!(kinds(&back), ["art", "instance"]);
let green = back.layers[0].children().unwrap()[0].clone();
@@ -6890,7 +6911,7 @@ fn symbol_options_and_linked_images_in_symbols_are_reported() {
let layer = doc.layers[0].id;
doc.insert(Some(layer), usize::MAX, one).unwrap();
let out = export_ai_editing(&doc, &opts()).unwrap();
assert_eq!(out.warnings, [writer::SYMBOL_OPTIONS, writer::LINKS_EMBEDDED]);
assert_eq!(out.warnings, [writer::LINKS_EMBEDDED]);
let p = program_shown(&doc);
assert!(p.contains("%AI5_BeginRaster") && !p.contains("%AI5_BeginPlace"), "{p}");
let back = read_back(&doc);
@@ -15982,3 +16003,56 @@ fn a_mesh_eight_levels_down_is_written_as_a_mesh() {
assert_eq!(back.len(), 1, "{back:#?}");
assert_mesh_exact(mesh_of(&back[0]), &want, "eight levels down");
}
fn dynamic_doc() -> Document {
let mut doc = Document::new(200.0, 100.0);
let art = square(&mut doc, Rect::new(0.0, 0.0, 10.0, 10.0), LEAF);
doc.symbols.push(Symbol { dynamic: true, name: "Leaf".into(), art: Arc::new(art) });
let layer = doc.layers[0].id;
for (x, c) in [(10.0, Color::rgb(1.0, 0.0, 0.0)), (50.0, Color::rgb(0.0, 0.0, 1.0))] {
let mut i = instance(&mut doc, "Leaf", Affine::translate((x, 10.0)));
i.extras_mut().symbol_overrides = vec![vectorcraft_doc::SymbolOverride { fill: Some(solid(c)), opacity: Some(0.5), ..Default::default() }];
doc.insert(Some(layer), usize::MAX, i).unwrap();
}
let plain = instance(&mut doc, "Leaf", Affine::translate((90.0, 10.0)));
doc.insert(Some(layer), usize::MAX, plain).unwrap();
doc
}
#[test]
fn dynamic_symbols_and_their_instance_changes_survive_a_round_trip() {
let doc = dynamic_doc();
let out = export_ai_editing(&doc, &opts()).unwrap();
assert_eq!(out.warnings, [writer::SYMBOL_CHANGES]);
let back = read_back(&doc);
assert!(back.symbols[0].dynamic);
let kids = back.layers[0].children().unwrap();
assert!(kids.iter().all(|n| matches!(n.kind, NodeKind::SymbolInstance { .. })));
let want: Vec<_> = doc.layers[0].children().unwrap().iter().map(|n| n.extras().symbol_overrides.clone()).collect();
let got: Vec<_> = kids.iter().map(|n| n.extras().symbol_overrides.clone()).collect();
assert_eq!(got, want);
assert_ne!(got[0], got[1]);
assert!(got[2].is_empty());
}
#[test]
fn static_symbols_write_no_dynamic_entries() {
let mut doc = dynamic_doc();
doc.symbols[0].dynamic = false;
let layer = doc.layers[0].id;
for n in doc.layers[0].children().unwrap().to_vec() {
doc.remove(n.id).unwrap();
}
for x in [10.0, 50.0] {
let i = instance(&mut doc, "Leaf", Affine::translate((x, 10.0)));
doc.insert(Some(layer), usize::MAX, i).unwrap();
}
let p = program(&doc);
assert!(!p.contains("VectorCraftDynamicSymbol") && !p.contains("VectorCraftSymbolOverrides"));
assert!(export_ai_editing(&doc, &opts()).unwrap().warnings.is_empty());
let back = read_back(&doc);
assert!(!back.symbols[0].dynamic);
let kids = back.layers[0].children().unwrap();
assert_eq!(kids.len(), 2);
assert!(kids.iter().all(|n| matches!(n.kind, NodeKind::SymbolInstance { .. }) && n.extras().symbol_overrides.is_empty()));
}
+25 -3
View File
@@ -48,8 +48,9 @@ pub(super) use paints::{
GRADIENT_COMPARISONS, GRADIENT_DITHER, GRADIENT_HUE, GRADIENT_PERCEPTUAL, GRADIENT_SHAPES, GRADIENTS, SCANNED_DEFINITIONS, STOP_LINKS,
SWATCH_PLACEMENT, free_gradient_name,
};
pub(crate) use symbols::{DYNAMIC_KEY, OVERRIDES_KEY, hex_decode};
#[cfg(test)]
pub(super) use symbols::{MISSING_SYMBOL, SYMBOL_ART, SYMBOL_COUNT, SYMBOL_OPTIONS};
pub(super) use symbols::{MISSING_SYMBOL, SYMBOL_ART, SYMBOL_CHANGES, SYMBOL_COUNT, SYMBOL_OPTIONS};
#[cfg(test)]
pub(super) use texts::{FONT_RESOLVES, RESOLVE_EACH_RUN, TYPE_ATTRIBUTES};
#[cfg(test)]
@@ -66,7 +67,9 @@ pub(super) const PATTERN_TILES: &str = "pattern fills with more tiles than a fil
pub(super) const CLIPPING: &str = "clipping groups and clipping layers whose clipping object isn't a path, and the clipping groups inside them, are written as their art cut to that object in the editing data for other apps";
pub(super) const CLIP_PAINT: &str = "the fills and strokes of clipping paths that a plain fill and line can't draw are written as paths of their own inside the clipping (fills under the clipped art, strokes over it) in the editing data for other apps";
pub(super) const CLIP_PAINT_MASKS: &str = "the opacity masks of clipping paths whose fills and strokes are written as paths of their own stay on the clipping path, not on those paths, in the editing data for other apps";
pub(super) const LIVE: &str = "repeats, placed documents and intertwines are written as their art in the editing data for other apps";
pub(super) const LIVE: &str =
"repeats, placed documents, intertwines and distorted images are written as their art in the editing data for other apps";
pub(super) const DEEP_DISTORTED: &str = "images changed by Perspective Distort or Free Distort more than 8 deep in opacity masks, symbols, live objects and pattern tiles are written as the nearest parallelogram in the editing data for other apps";
pub(super) const GRAPHS: &str = "graphs are written as their art, without their data or settings, in the editing data for other apps";
pub(super) const STROKES: &str = "strokes a plain line can't draw (inside or outside the path, variable width, dots, dashes fitted to corners, gradients, patterns, arrowheads) are written as filled outlines, and brushed strokes as their brush's art, in the editing data for other apps";
pub(super) const ITEM_TRANSPARENCY: &str =
@@ -286,6 +289,7 @@ pub(super) struct Writer<'a> {
symbol_scales: HashMap<String, f64>,
/// The entries a symbol's dictionary adds to its art's dictionary, and the art's id.
root_entries: Option<(vectorcraft_doc::NodeId, String)>,
instance_entries: Option<(vectorcraft_doc::NodeId, String)>,
/// The objects that may be written with an art style, as they were before baking, by id
/// ([`styles::styled_objects`]).
pub(super) styled: HashMap<NodeId, Arc<Node>>,
@@ -405,6 +409,7 @@ impl<'a> Writer<'a> {
inner_scale: 1.0,
symbol_scales: HashMap::new(),
root_entries: None,
instance_entries: None,
styled: HashMap::new(),
symbol_styled: HashMap::new(),
pattern_styled: HashMap::new(),
@@ -799,6 +804,7 @@ impl<'a> Writer<'a> {
}
NodeKind::Compound { rule, .. } => self.shape(n, &compound_path(n), *rule, xy),
NodeKind::Text(_) => self.text(n, xy),
NodeKind::Image(im) if n.is_distorted_image() => self.distorted_image(n, im, xy),
NodeKind::Image(im) => {
// An opacity mask that clips shows the image within what its art paints only (its
// effects and its symbol instances' art included, as the renderer measures it).
@@ -818,7 +824,7 @@ impl<'a> Writer<'a> {
mask_window = self.windowed.take();
}
}
NodeKind::SymbolInstance { symbol, xf } if self.live_instance_in_room(n, symbol, *xf) => self.symbol_instance(symbol, *xf, xy),
NodeKind::SymbolInstance { symbol, xf } if self.live_instance_in_room(n, symbol, *xf) => self.symbol_instance(n, symbol, *xf, xy),
NodeKind::SymbolInstance { symbol, xf } => {
if !self.open_group("u") {
return;
@@ -944,6 +950,18 @@ impl<'a> Writer<'a> {
self.warn(GRAPHS);
}
/// Distorted image `n` (`im`), of transparency `xy`: the mesh of its pieces while the art may
/// nest further, else one image at the placement nearest its corners, with a warning.
fn distorted_image(&mut self, n: &Node, im: &vectorcraft_doc::ImageObject, xy: Xy) {
if self.nest < MAX_NEST {
return self.drawn_art(n, xy, Some(LIVE), true);
}
let Some(near) = vectorcraft_doc::image_quad::nearest_affine(n) else { return };
self.warn(DEEP_DISTORTED);
self.windowed = None;
self.image(&vectorcraft_doc::ImageObject { xf: near, ..self.doc.shown_image(n, im).into_owned() }, xy);
}
/// Live object `n`, of transparency `xy`, as a group of its art, with `warning` when it is given.
/// With `bounds`, `n`'s text wrap options go on the rectangle of its bounds, the group's first
/// member ([`Self::wrap_on_bounds`]); without it, in the group's dictionary.
@@ -1016,6 +1034,10 @@ impl<'a> Writer<'a> {
Some((id, _)) if *id == n.id => self.root_entries.take().map(|(_, e)| e),
_ => None,
};
let entries = match &self.instance_entries {
Some((id, _)) if *id == n.id => entries.or_else(|| self.instance_entries.take().map(|(_, e)| e)),
_ => entries,
};
let role = match &self.blend_role {
Some((id, _)) if *id == n.id => self.blend_role.take().map(|(_, e)| e),
_ => None,
+38 -5
View File
@@ -14,7 +14,27 @@ use crate::ps;
pub(in crate::ai_editing) const SYMBOL_ART: &str = "symbol instances with a fill, appearance changes, isolation, knockout or knockout shape of their own, instances of symbols with 9-slice guides or pattern paint, instances in pattern tiles or in art cut to a clipping object, instances scaled almost flat, instances that turn, mirror or scale symbols holding type, live objects, instances written as their art, shapes with rounded live corners or strokes written as outlines or brush art, instances that scale their symbol more than 100 times, instances on the layers of a large canvas and instances of symbols past 4,096 are written as their art in the editing data for other apps";
pub(in crate::ai_editing) const SYMBOL_OPTIONS: &str =
"the 9-slice guides, export types and dynamic type of symbols are left out of the editing data for other apps";
"the 9-slice guides and export types of symbols are left out of the editing data for other apps";
pub(in crate::ai_editing) const SYMBOL_CHANGES: &str =
"the changes of dynamic symbol instances are kept in dictionary entries of their own, which other apps leave out";
pub(crate) const DYNAMIC_KEY: &str = "VectorCraftDynamicSymbol";
pub(crate) const OVERRIDES_KEY: &str = "VectorCraftSymbolOverrides";
const MAX_OVERRIDES_BYTES: usize = 1 << 20;
pub(crate) fn hex_decode(s: &str) -> Option<Vec<u8>> {
if !s.len().is_multiple_of(2) || s.len() / 2 > MAX_OVERRIDES_BYTES {
return None;
}
s.as_bytes().chunks(2).map(|c| u8::from_str_radix(std::str::from_utf8(c).ok()?, 16).ok()).collect()
}
fn hex_encode(b: &[u8]) -> String {
b.iter().fold(String::with_capacity(b.len() * 2), |mut s, v| {
let _ = write!(s, "{v:02x}");
s
})
}
pub(in crate::ai_editing) const MISSING_SYMBOL: &str =
"symbol instances of symbols the document doesn't have are written as empty groups in the editing data for other apps";
/// The most an instance may scale its symbol's art, nested instances' scales included: the art's
@@ -55,7 +75,8 @@ impl Writer<'_> {
/// that keeps the art's area as it is written and scales it as the definition allows
/// ([`Self::keeps_scale`]).
pub(super) fn live_instance(&mut self, n: &Node, symbol: &str, xf: Affine) -> bool {
let own = vectorcraft_brush::stain(n).is_some() || !n.extras().symbol_overrides.is_empty();
let dynamic = self.symbol_doc.symbols.iter().any(|s| s.name == symbol && s.dynamic);
let own = vectorcraft_brush::stain(n).is_some() || (!dynamic && !n.extras().symbol_overrides.is_empty());
let group_state = n.isolate || n.knockout != Knockout::Neutral || n.knockout_shape;
// The matrix as written (to ten decimals) must still keep the art's area.
let m = Affine::new((self.instance_space * xf).as_coeffs().map(|v| (v * 1e10).round() / 1e10));
@@ -153,7 +174,16 @@ impl Writer<'_> {
/// canvas's space turned y up about art space's origin there) as `a b c d tx ty
/// /RTransformMatrix` (to ten decimals), `;`, then its state block as a group's: `Xy`, `0 0 Xd`
/// and `6 () XW` when it has transparency, else `9 () XW`. Its dictionary goes between the two.
pub(super) fn symbol_instance(&mut self, symbol: &str, xf: Affine, xy: Xy) {
pub(super) fn symbol_instance(&mut self, n: &Node, symbol: &str, xf: Affine, xy: Xy) {
let o = &n.extras().symbol_overrides;
if !o.is_empty()
&& let Ok(json) = serde_json::to_vec(o)
&& json.len() <= MAX_OVERRIDES_BYTES
{
let e = format!("%_{} /String ({OVERRIDES_KEY}) ,\n", ps::bytes(hex_encode(&json).as_bytes()));
self.instance_entries = Some((n.id, e));
self.warn(SYMBOL_CHANGES);
}
let m = self.instance_space * xf;
let _ = write!(self.body, "/SymbolInstance :\n{} /SymbolRef ,\n", ps::bytes(symbol.as_bytes()));
for v in m.as_coeffs() {
@@ -201,7 +231,7 @@ impl Writer<'_> {
self.warn(SYMBOL_COUNT);
return false;
}
if sym.dynamic || doc.symbol_export_type(name) != SymbolExportType::default() || doc.symbol_nine_slice(name).is_some() {
if doc.symbol_export_type(name) != SymbolExportType::default() || doc.symbol_nine_slice(name).is_some() {
self.warn(SYMBOL_OPTIONS);
}
// The art's effects are its own, not those of a drawn look that first places it, and its
@@ -260,7 +290,10 @@ impl Writer<'_> {
(self.to_art, self.grad_space, self.canvas, self.instance_space) = (Affine::IDENTITY, about_origin, Affine::IDENTITY, about_origin);
self.block_end = usize::MAX;
let registration = u16::from(doc.symbol_registration(name).0.min(8)) + 1;
let entries = format!("%_{registration} /Int (AI13PatternRegistrationType) ,\n");
let mut entries = format!("%_{registration} /Int (AI13PatternRegistrationType) ,\n");
if sym.dynamic {
let _ = writeln!(entries, "%_1 /Int ({DYNAMIC_KEY}) ,");
}
// The canvas draws a symbol's art even when its root is hidden, so the root is written shown.
let shown;
let root: &Node = if sym.art.visible {
+2 -2
View File
@@ -627,7 +627,7 @@ impl<'a> Reader<'a> {
|| sub.mesh.is_some()
|| sub.gradient_def.is_some();
let head = sub.symbol.take().unwrap_or_default();
let registration = head.registration;
let (registration, dynamic) = (head.registration, head.dynamic);
let measured = read.is_ok() && !open && sub.unsupported.is_empty() && sub.unknown.is_empty() && sub.frames.len() == 1;
let Some(frame) = sub.frames.pop().filter(|_| measured) else { return };
let mut kids = frame.children;
@@ -669,7 +669,7 @@ impl<'a> Reader<'a> {
}
}
let named = self.unique_symbol_name(if name.is_empty() { "Symbol" } else { &name });
self.doc.symbols.push(Symbol { name: named.clone(), art: Arc::new(art), dynamic: false });
self.doc.symbols.push(Symbol { name: named.clone(), art: Arc::new(art), dynamic });
if let Some(reg) = registration.and_then(symbol_registration) {
self.doc.set_symbol_registration(&named, reg);
}
+13
View File
@@ -783,6 +783,19 @@ impl<'a> Reader<'a> {
{
head.registration = Some(*r);
}
if self.frames.len() == 1
&& let Some(head) = self.symbol.as_mut()
&& o.nums(crate::ai_editing::DYNAMIC_KEY).first().is_some_and(|v| *v != 0.0)
{
head.dynamic = true;
}
if let Some(text) = o.text(crate::ai_editing::OVERRIDES_KEY)
&& let Some(bytes) = crate::ai_editing::hex_decode(&text)
&& let Ok(list) = serde_json::from_slice::<Vec<vectorcraft_doc::SymbolOverride>>(&bytes)
&& let Some(n) = self.last_object().filter(|n| matches!(n.kind, NodeKind::SymbolInstance { .. }))
{
n.extras_mut().symbol_overrides = list.into_iter().filter(|s| !s.is_empty()).collect();
}
self.constraint_art(o);
self.placed_page(o);
// A blend's key object or spine.
+1
View File
@@ -244,6 +244,7 @@ pub(super) struct PatternHead {
pub(super) struct SymbolHead {
/// `AI13PatternRegistrationType` in the dictionary after the art.
pub(super) registration: Option<f64>,
pub(super) dynamic: bool,
/// Art the reader left out (type, a placed file, non-native art, an image it can't read or
/// place, a gradient it can't read): the symbol isn't kept, and its instances come in as the
/// page draws them, within the box of the rest.
+3 -1
View File
@@ -128,7 +128,9 @@ const CONIC_WEDGES: usize = 360;
const STROKES: &str =
"strokes a plain line can't draw (inside or outside the path, variable width, gradients, brushes, arrowheads) are written as filled outlines";
const IMAGE_ALPHA: &str = "transparent image pixels are written over white";
const LIVE: &str = "symbols, blends, envelopes, meshes, repeats, placed documents and intertwines are written as their art";
const LIVE: &str = "symbols, blends, envelopes, meshes, repeats, placed documents, intertwines and distorted images are written as their art";
const DEEP_DISTORTED: &str =
"images changed by Perspective Distort or Free Distort more than 8 deep in symbols and live objects are written as the nearest parallelogram";
const GRAPHS: &str = "graphs are written as their art, without their data or settings";
/// The warning for an image left out because it can't be decoded: the note raster exports give
/// (`vectorcraft-engine`'s `rasterfx::undecoded_warning`).
+19
View File
@@ -703,6 +703,25 @@ fn picture(doc: &mut Document, r: Rect) -> Node {
)
}
/// A distorted image as deep as the writer goes, the art of the innermost of 8 nested symbols, is
/// written as one image at the placement nearest its corners, with a warning, not left out.
#[test]
fn a_distorted_image_nested_as_deep_as_the_limit_is_written_as_its_nearest_placement() {
let mut doc = Document::new(200.0, 100.0);
let mut art = picture(&mut doc, Rect::new(10.0, 10.0, 90.0, 90.0));
art.set_image_corners([(40.0, 10.0), (60.0, 10.0), (90.0, 90.0), (10.0, 90.0)].map(|(x, y)| vectorcraft_geom::Point::new(x, y))).unwrap();
for i in 0..8 {
let name = format!("S{i}");
doc.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: name.clone(), art: Arc::new(art) });
art = Node::new(doc.alloc_id(), NodeKind::SymbolInstance { symbol: name, xf: Affine::IDENTITY });
}
doc.insert(doc.default_layer(), usize::MAX, art).unwrap();
let out = write(&doc);
assert!(out.warnings.iter().any(|w| w == DEEP_DISTORTED), "{:?}", out.warnings);
let text = String::from_utf8(out.bytes).unwrap();
assert_eq!(text.lines().filter(|l| l.ends_with(" XI")).count(), 1, "the one image");
}
/// A layer `Below` holding a clipping group (a circle clipping an image, as in #2692), a group
/// holding an image and an image; a layer `Above` holding an orange square. Without `images`,
/// `Below` is empty.
+14 -4
View File
@@ -9,7 +9,7 @@ use super::{
ROTATED_TYPE, Rect, STROKES, SUBLAYERS, Shape, StrokeLayer, SubPath, TITLE_AND_COLOR_NAMES, TRANSPARENCY, TYPE, TYPE_ATTRIBUTES, TextKind,
TextObject, UNDECODED, Vec2, Write, ai_ops, latin, ps, stroke,
};
use super::{CONIC, CONIC_WEDGES, DIAMOND, GRAPHS, HUE_STOPS, PERCEPTUAL_STOPS, SPREAD, SPREAD_CAPPED};
use super::{CONIC, CONIC_WEDGES, DEEP_DISTORTED, DIAMOND, GRAPHS, HUE_STOPS, PERCEPTUAL_STOPS, SPREAD, SPREAD_CAPPED};
#[cfg(test)]
thread_local! {
@@ -322,14 +322,23 @@ impl<'a> Writer<'a> {
self.lock(locked);
self.text(t);
}
NodeKind::Image(im) => {
// A distorted image too deep for its pieces is written at the placement nearest its
// corners.
NodeKind::Image(im) if !n.is_distorted_image() || self.nest >= MAX_NEST => {
self.lock(locked);
let shown = self.doc.shown_image(n, im);
let blob = self.doc.image_blob(&shown);
// A colorize color the renderer draws the image in.
let colorize =
n.extras().colorize.as_deref().filter(|p| matches!(p, Paint::Solid { .. }) && blob.is_some_and(ImageBlob::takes_colorize));
self.image(blob, im.width, im.height, im.xf, colorize);
let xf = match vectorcraft_doc::image_quad::nearest_affine(n) {
Some(near) => {
self.warn(DEEP_DISTORTED);
near
}
None => im.xf,
};
self.image(blob, im.width, im.height, xf, colorize);
}
NodeKind::SymbolInstance { symbol, xf } => {
self.warn(LIVE);
@@ -348,7 +357,8 @@ impl<'a> Writer<'a> {
| NodeKind::Mesh(_)
| NodeKind::Repeat(_)
| NodeKind::PlacedDocument(_)
| NodeKind::Intertwine { .. } => {
| NodeKind::Intertwine { .. }
| NodeKind::Image(_) => {
self.warn(LIVE);
if self.nest < MAX_NEST {
let g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);
+5 -3
View File
@@ -585,7 +585,7 @@ impl<'a> Scene<'a> {
self.shape(n, &bp, *rule);
}
NodeKind::Text(t) => self.text(n, t),
NodeKind::Image(im) => {
NodeKind::Image(im) if !n.is_distorted_image() => {
let shown = self.doc.shown_image(n, im);
let im = &*shown;
let blob = self.doc.image_blob(im);
@@ -606,13 +606,15 @@ impl<'a> Scene<'a> {
self.nest -= 1;
}
}
// Live blends, envelopes, meshes and repeats are written as their evaluated art.
// Live blends, envelopes, meshes and repeats (and distorted images) are written as
// their evaluated art.
NodeKind::Blend { .. }
| NodeKind::Envelope { .. }
| NodeKind::Mesh(_)
| NodeKind::Repeat(_)
| NodeKind::PlacedDocument(_)
| NodeKind::Intertwine { .. } => {
| NodeKind::Intertwine { .. }
| NodeKind::Image(_) => {
let g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);
for c in g.children().into_iter().flatten() {
self.node(c, false);
+44
View File
@@ -1255,6 +1255,50 @@ fn an_envelopes_image_pieces_draw_one_copy_of_its_samples() {
}
}
/// An image changed by Perspective Distort is written as the pieces of its mesh, placed so that
/// its pixel rectangle's corners land on its corners: read back, each corner of the quad is a
/// corner of one of the pieces' images.
#[test]
fn a_distorted_image_is_written_with_its_corners_on_its_quad() {
let mut d = png_doc();
let id = d.layers[0].children().unwrap()[0].id;
let q = [(40.0, 10.0), (60.0, 10.0), (90.0, 90.0), (10.0, 90.0)].map(|(x, y)| Point::new(x, y));
d.node_mut(id).unwrap().set_image_corners(q).unwrap();
for level in Level::ALL {
let out = export(&d, &EpsOptions { level, ..opts(&d) }, None, None).unwrap();
let back = import::import(&out.bytes).unwrap().document;
let (mut seen, mut pieces) = ([false; 4], 0);
back.walk(|n| {
if let NodeKind::Image(im) = &n.kind {
pieces += 1;
let (w, h) = (f64::from(im.width), f64::from(im.height));
for p in [(0.0, 0.0), (w, 0.0), (w, h), (0.0, h)] {
let at = im.xf * Point::new(p.0, p.1);
for (i, c) in q.iter().enumerate() {
seen[i] |= at.distance(*c) < 0.01;
}
}
}
});
assert!(pieces > 2, "{level:?}: {pieces}");
assert_eq!(seen, [true; 4], "{level:?}");
// The pieces are clipped by the quad: a clipping path with its bounds and its area.
let mut quad_clips = 0;
back.walk(|n| {
if let NodeKind::Group { children, clip: true } = &n.kind
&& let Some(p) = children.first().and_then(|c| c.path_data())
&& let Some(b) = p.bounds()
{
let area: f64 = p.subpaths.iter().map(|s| s.area()).sum::<f64>().abs();
if [b.x0 - 10.0, b.y0 - 10.0, b.x1 - 90.0, b.y1 - 90.0].iter().all(|v| v.abs() < 0.01) && (area - 4000.0).abs() < 1.0 {
quad_clips += 1;
}
}
});
assert!(quad_clips >= 1, "{level:?}: no clipping path on the quad");
}
}
#[test]
fn each_ink_of_a_colorized_image_placed_twice_is_written_once() {
let first = Paint::Solid { color: Color::rgb8(255, 0, 0), swatch: Some("Ink".into()), tint: 1.0 };
+13 -1
View File
@@ -687,6 +687,18 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"{pinned?: bool} keep the Contextual Task Bar where it is instead of following the selection (true), let it follow the selection again from where it is (false) or toggle (omitted), as the bar's More Options menu does; returns the new state",
),
("window.taskBar.reset", "Reset Bar Position", "", "{} unpin the Contextual Task Bar and put it back under the selection"),
(
"window.taskBar.actions",
"Bar Actions",
"",
"{action: \"imageTrace\"|\"cropImage\"|\"removeBackground\"|\"removeAnchorPoints\"|\"join\"|\"cutPath\"|\"convertToCorner\"|\"convertToSmooth\"|\"group\"|\"makeClippingMask\"|\"unite\"|\"expand\"|\"editClippingPath\"|\"releaseClippingMask\"|\"ungroup\"|\"isolate\"|\"editPath\"|\"releaseCompoundPath\"|\"createOutlines\"|\"convertToPointType\"|\"convertToAreaType\"|\"typeOnPathOptions\"|\"centerOnTop\"|\"centerOnBottom\"|\"dynamicText\"|\"offsetPath\"|\"simplify\"|\"smooth\"|\"duplicate\"|\"drawPencil\"|\"placeImage\"|\"fidelity\"|\"smoothToolOptions\"|\"resizeArtboard\"|\"duplicateArtboards\"|\"rearrangeArtboards\"|\"exportArtboards\"|\"fill\"|\"stroke\"|\"recolor\"|\"lock\"|\"shapeProperties\", visible?: bool} show (true), hide (false) or toggle (omitted or null) one of the Contextual Task Bar's actions or chips, as the bar's More Options › Bar Actions does; an action that is off stays out of the bar and out of More Options, and turning one off changes only the bar; `join` is both Connect and Join; every action starts on; kept with the preferences and with the workspace; another action, or a `visible` that is not true, false or null, is an error and changes nothing; returns {action, visible}",
),
(
"window.taskBar.resetActions",
"Reset Bar Actions",
"",
"{} show every Contextual Task Bar action and chip that Bar Actions turned off, as the bar's More Options › Reset Bar Actions does; returns the ids shown again",
),
(
"window.dock",
"Panels",
@@ -1561,7 +1573,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
"ui.colorWheel",
"Color Wheel Options",
"",
"{view?: wheel|box, channel?: hue|saturation|brightness|red|green|blue, harmony?: bool, harmonyRule?: complementary|splitComplementary|leftComplement|rightComplement|analogous|analogous2|triad|tetrad|tetrad2|tetrad3|compound|compound2|highContrast|highContrast3|pentagram, vision?: bool} show the Color Wheel panel's wheel or its box, as the panel menu's Wheel View and Box View do, and pick the box's channel, as Box Channel does: the box is a color field with the channel's strip at its right, and the field shows the other two components (hue: saturation across and brightness up; saturation: hue across and brightness up; brightness: hue across and saturation up; red: blue across and green up; green: blue across and red up; blue: red across and green up); harmony shows a marker on the wheel's ring for each other color of harmonyRule (the Color Guide's rule of that id; a rule's label is taken too), as Show Harmony and Harmony Rule do, and a click on a marker applies its color; vision shows Show Color Vision Preview's row under the wheel or the box, four chips with the current color as simulated for protanopia, deuteranopia and tritanopia (the simulations of view.proofSetup's protanopia, deuteranopia and tritanopia targets) and for achromatopsia (the gray with the color's CIE L*), each named with its hex value in its tooltip and to screen readers, and taking the keyboard focus; a click or a key on a chip does not apply its color; keys left out or null keep their values ({} reads them), params that are not an object, another key or a value off the list are an error and change nothing, the settings are kept with the preferences, and the command does not open the panel (window.panel {panel: \"colorWheel\"} does) (ui.inspect: ui.color_wheel) → {view, channel, harmony, harmonyRule, vision}",
"{view?: wheel|box, channel?: hue|saturation|brightness|red|green|blue, sliders?: none|oklch|hsl, harmony?: bool, harmonyRule?: complementary|splitComplementary|leftComplement|rightComplement|analogous|analogous2|triad|tetrad|tetrad2|tetrad3|compound|compound2|highContrast|highContrast3|pentagram, vision?: bool} show the Color Wheel panel's wheel or its box, as the panel menu's Wheel View and Box View do, pick the box's channel, as Box Channel does, and show no slider rows under the wheel or the box (none), OKLCH Sliders (oklch) or HSL Sliders (hsl), as the menu items of those names do: the box is a color field with the channel's strip at its right, and the field shows the other two components (hue: saturation across and brightness up; saturation: hue across and brightness up; brightness: hue across and saturation up; red: blue across and green up; green: blue across and red up; blue: red across and green up); OKLCH Sliders edit lightness 0 to 100 %, chroma 0 to 100 % of 0.4 and hue 0 to 360°, CSS Color 4's OKLCH of the display sRGB, and a color outside sRGB keeps L and H and takes the largest chroma that fits; HSL Sliders edit hue 0 to 360°, saturation 0 to 100 % and lightness 0 to 100 %, CSS Color 4's HSL of the display sRGB; harmony shows a marker on the wheel's ring for each other color of harmonyRule (the Color Guide's rule of that id; a rule's label is taken too), as Show Harmony and Harmony Rule do, and a click on a marker applies its color; vision shows Show Color Vision Preview's row under the wheel or the box, four chips with the current color as simulated for protanopia, deuteranopia and tritanopia (the simulations of view.proofSetup's protanopia, deuteranopia and tritanopia targets) and for achromatopsia (the gray with the color's CIE L*), each named with its hex value in its tooltip and to screen readers, and taking the keyboard focus; a click or a key on a chip does not apply its color; keys left out or null keep their values ({} reads them), params that are not an object, another key or a value off the list are an error and change nothing, oklch is an error while the working RGB space is not sRGB, the settings are kept with the preferences, and the command does not open the panel (window.panel {panel: \"colorWheel\"} does) (ui.inspect: ui.color_wheel) → {view, channel, sliders, harmony, harmonyRule, vision}",
),
(
"ui.savePdfDialog",
+67 -1
View File
@@ -31,6 +31,7 @@ const BLENDING: &str = "blending modes are left out";
const MASKS: &str = "opacity masks are left out";
const RASTER_FX: &str = "raster effects (shadows, glows, blurs, feathering) are left out";
const CLIPPING: &str = "clipping masks are not applied: the art they clip is written whole";
const DISTORTED_IMAGES: &str = "images changed by Perspective Distort or Free Distort are written as the nearest parallelogram";
const FLAT_GRADIENTS: &str = "gradients are written as one colour, the average of their stops";
const FLAT_PATTERNS: &str = "pattern fills are written as one colour";
const TOO_MANY_TILES: &str = "pattern fills past 250,000 tiles in all are written as one colour";
@@ -134,6 +135,9 @@ pub(crate) struct Scene<'a> {
/// Pattern tiles being written that may be merged: their parts aren't left out off the page,
/// so each tile draws the same parts (the fill's clip still trims them).
whole_tiles: bool,
/// While the pieces of a distorted image are written: the box of the clips around the current
/// object (`Some(None)` before the first), to which each piece's image is cropped.
crop: Option<Option<Rect>>,
}
impl<'a> Scene<'a> {
@@ -151,6 +155,7 @@ impl<'a> Scene<'a> {
nest: 0,
tiles_left: MAX_TILES,
whole_tiles: false,
crop: None,
}
}
@@ -213,7 +218,24 @@ impl<'a> Scene<'a> {
self.node(&o, true);
}
}
NodeKind::Image(im) => self.image(&self.doc.shown_image(n, im)),
NodeKind::Image(im) => match vectorcraft_doc::image_quad::nearest_affine(n) {
// A format that clips writes a distorted image as the pieces of its mesh; one that
// doesn't, at the affine placement nearest its corners.
// Each piece stores only the pixels inside its clips.
Some(_) if self.clips => {
let g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);
let outer = self.crop.replace(None);
for c in g.children().into_iter().flatten() {
self.node(c, false);
}
self.crop = outer;
}
Some(xf) => {
self.warn(DISTORTED_IMAGES);
self.image(&ImageObject { xf, ..self.doc.shown_image(n, im).into_owned() });
}
None => self.image(&self.doc.shown_image(n, im)),
},
NodeKind::SymbolInstance { symbol, xf } => {
if let Some(sym) = self.doc.symbols.iter().find(|s| &s.name == symbol)
&& self.nest < MAX_NEST
@@ -261,13 +283,19 @@ impl<'a> Scene<'a> {
None
};
let clipped = outline.is_some();
let outer_crop = self.crop;
if let Some((path, rule)) = outline {
if let Some(c) = self.crop {
let b = path.bounding_box();
self.crop = Some(Some(c.map_or(b, |c| c.intersect(b))));
}
self.ops.push(Op::Clip { path, rule });
}
if let Some(f) = &paint.fill {
self.node(f, false);
}
rest.iter().for_each(|c| self.node(c, false));
self.crop = outer_crop;
if clipped {
self.ops.push(Op::Unclip);
}
@@ -478,6 +506,13 @@ impl<'a> Scene<'a> {
let Some(img) = self.decoded(im) else { return };
let (dw, dh) = (f64::from(img.width), f64::from(img.height));
let xf = im.xf * Affine::scale_non_uniform(f64::from(im.width.max(1)) / dw, f64::from(im.height.max(1)) / dh);
let (img, xf) = match self.crop.flatten() {
Some(c) => match cropped(&img, xf, c) {
Some((part, x0, y0)) => (Arc::new(part), xf * Affine::translate((f64::from(x0), f64::from(y0)))),
None => return,
},
None => (img, xf),
};
self.ops.push(Op::Image { image: img, xf, opacity: self.opacity.clamp(0.0, 1.0) });
}
@@ -503,6 +538,37 @@ impl<'a> Scene<'a> {
}
}
/// The pixels of `img`, drawn by `xf`, that `clip` (a box in the document) shows, with one pixel
/// more on each side: the part and its top left pixel. The whole image when `xf` cannot be
/// inverted; `None` when `clip` shows none of it.
fn cropped(img: &Rgba, xf: Affine, clip: Rect) -> Option<(Rgba, u32, u32)> {
if xf.determinant().abs() < 1e-12 || !xf.determinant().is_finite() {
return Some((img.clone(), 0, 0));
}
let inv = xf.inverse();
let corners =
[Point::new(clip.x0, clip.y0), Point::new(clip.x1, clip.y0), Point::new(clip.x1, clip.y1), Point::new(clip.x0, clip.y1)].map(|p| inv * p);
let (w, h) = (f64::from(img.width), f64::from(img.height));
let lo = |f: fn(&Point) -> f64| corners.iter().map(f).fold(f64::INFINITY, f64::min);
let hi = |f: fn(&Point) -> f64| corners.iter().map(f).fold(f64::NEG_INFINITY, f64::max);
let (x0, y0) = ((lo(|p| p.x).floor() - 1.0).max(0.0), (lo(|p| p.y).floor() - 1.0).max(0.0));
let (x1, y1) = ((hi(|p| p.x).ceil() + 1.0).min(w), (hi(|p| p.y).ceil() + 1.0).min(h));
if !(x0 < x1 && y0 < y1) {
return None;
}
let (x0, y0, x1, y1) = (x0 as u32, y0 as u32, x1 as u32, y1 as u32);
if (x0, y0, x1, y1) == (0, 0, img.width, img.height) {
return Some((img.clone(), 0, 0));
}
let row = img.width as usize * 4;
let mut pixels = Vec::with_capacity((x1 - x0) as usize * (y1 - y0) as usize * 4);
for y in y0..y1 {
let start = y as usize * row + x0 as usize * 4;
pixels.extend_from_slice(img.pixels.get(start..start + (x1 - x0) as usize * 4)?);
}
Some((Rgba { width: x1 - x0, height: y1 - y0, pixels }, x0, y0))
}
/// Do the instances of `def` stay apart? A grid or brick tiling places its tiles side by side, so
/// art that stays in its tile never overlaps another instance's; hex tilings overlap their tiles.
fn tiles_apart(def: &vectorcraft_doc::PatternDef) -> bool {
+76
View File
@@ -288,6 +288,82 @@ fn emf_clips_gradients_and_images() {
assert_eq!((count(&k, 35), count(&k, 36)), (3, 3));
}
/// An image changed by Perspective Distort is written as the clipped pieces of its mesh where
/// the format clips (EMF), and as one image at the placement nearest its corners, with a warning,
/// where it does not (WMF).
#[test]
fn a_distorted_image_is_its_mesh_with_clips_and_its_nearest_parallelogram_without() {
let mut d = doc_with(100.0, 100.0, vec![]);
let img = image_node(&mut d, png(4, 4, [10, 20, 30, 255]), 4, 4, Affine::scale(10.0));
add(&mut d, img);
let id = d.layers[0].children().unwrap()[0].id;
let q = [(16.0, 0.0), (24.0, 0.0), (40.0, 40.0), (0.0, 40.0)].map(|(x, y)| Point::new(x, y));
d.node_mut(id).unwrap().set_image_corners(q).unwrap();
let images = |ops: &[crate::scene::Op]| ops.iter().filter(|o| matches!(o, crate::scene::Op::Image { .. })).count();
let warned = |w: &[String]| w.iter().any(|w| w.contains("Perspective Distort or Free Distort"));
let (ops, warnings) = crate::scene::Scene::new(&d, d.artboards[0].rect, true).run();
assert!(images(&ops) > 2 && !warned(&warnings), "{} images, {warnings:?}", images(&ops));
let (ops, warnings) = crate::scene::Scene::new(&d, d.artboards[0].rect, false).run();
assert!(images(&ops) == 1 && warned(&warnings), "{} images, {warnings:?}", images(&ops));
// Without clips, the image is placed by the affine map nearest its corners.
let near = vectorcraft_doc::image_quad::nearest_affine(d.node(id).unwrap()).unwrap();
let placed = ops.iter().find_map(|o| match o {
crate::scene::Op::Image { xf, .. } => Some(*xf),
_ => None,
});
assert!(placed.unwrap().as_coeffs().iter().zip(near.as_coeffs()).all(|(a, b)| (a - b).abs() < 1e-9), "{placed:?} against {near:?}");
}
/// Each piece of a distorted image's mesh in EMF stores the pixels inside its clips, not the
/// whole image, placed where the uncropped piece puts them.
#[test]
fn the_pieces_of_a_distorted_image_store_only_the_pixels_they_show() {
let mut pixels = vec![];
for y in 0..64u8 {
for x in 0..64u8 {
pixels.extend_from_slice(&[x * 4, y * 4, 0, 255]);
}
}
let img =
craft_image_codecs::Image::from_raw(64, 64, craft_image_codecs::ChannelLayout::Rgba, craft_image_codecs::SampleType::U8, pixels).unwrap();
let bytes = craft_image_codecs::encode(&img, craft_image_codecs::Format::Png, &craft_image_codecs::EncodeOptions::default()).unwrap();
let mut d = doc_with(100.0, 100.0, vec![]);
let n = image_node(&mut d, bytes, 64, 64, Affine::scale(1.5));
add(&mut d, n);
let id = d.layers[0].children().unwrap()[0].id;
let q = [(30.0, 0.0), (66.0, 0.0), (96.0, 96.0), (0.0, 96.0)].map(|(x, y)| Point::new(x, y));
d.node_mut(id).unwrap().set_image_corners(q).unwrap();
let art = vectorcraft_doc::image_quad::distorted_art(d.node(id).unwrap()).unwrap();
let whole: Vec<Affine> = vectorcraft_doc::image_quad::distorted_pieces(&art)
.iter()
.filter_map(|p| match &p.children()?.get(1)?.kind {
NodeKind::Image(im) => Some(im.xf),
_ => None,
})
.collect();
let (ops, _) = crate::scene::Scene::new(&d, d.artboards[0].rect, true).run();
let parts: Vec<(&crate::dib::Rgba, Affine)> = ops
.iter()
.filter_map(|o| match o {
crate::scene::Op::Image { image, xf, .. } => Some((&**image, *xf)),
_ => None,
})
.collect();
assert_eq!(parts.len(), whole.len());
assert!(parts.len() > 8, "{}", parts.len());
let stored: u64 = parts.iter().map(|(i, _)| u64::from(i.width) * u64::from(i.height)).sum();
assert!(stored * 4 < 64 * 64 * parts.len() as u64, "{stored} pixels in {} pieces", parts.len());
for ((part, xf), full) in parts.iter().zip(&whole) {
// The part's first pixel names where it starts in the image.
let (x0, y0) = (f64::from(part.pixels[0] / 4), f64::from(part.pixels[1] / 4));
let want = *full * Affine::translate((x0, y0));
assert!(xf.as_coeffs().iter().zip(want.as_coeffs()).all(|(a, b)| (a - b).abs() < 1e-6), "{xf:?} against {want:?}");
// Each row runs on from that pixel.
let last = (part.width as usize - 1) * 4;
assert_eq!(f64::from(part.pixels[last] / 4), x0 + f64::from(part.width - 1));
}
}
#[test]
fn type_is_written_as_outlines() {
let t = TextObject::point(Point::new(10.0, 50.0), "Hi", CharStyle { fill: red(), ..CharStyle::default() });
+3 -1
View File
@@ -28,7 +28,9 @@ pub use edit::{
};
pub use fit::{fit_cubics, fit_cubics_through};
pub use offset::{Cap, Join, MAX_OFFSET_SEGMENT_PAIRS, offset_path, outline_stroke, stroke_region, try_offset_path};
pub use pathfinder::{FaceMerger, PathfinderOp, Region, Shape, merge_regions, pathfinder, pathfinder_with, region_at, regions, regions_within};
pub use pathfinder::{
FaceMerger, PathfinderOp, Region, Shape, merge_regions, pathfinder, pathfinder_with, region_at, regions, regions_with, regions_within,
};
pub use planar::{
Adjacency, BuilderArrangement, MapEdge, MapFace, MapOutline, SHAPE_BUILDER_MAX_GAP, SHAPE_BUILDER_MAX_SEGMENTS, adjacency, cut_out,
encloses_area, find_gaps, has_open_path, interior_point, live_paint, live_paint_with_gaps, run_around, shape_builder, shape_builder_with_gap,
+1 -1
View File
@@ -557,7 +557,7 @@ pub fn regions(shapes: &[Shape]) -> Vec<Region> {
}
/// [`regions`] refit to `precision`.
pub(crate) fn regions_with(shapes: &[Shape], precision: f64) -> Vec<Region> {
pub fn regions_with(shapes: &[Shape], precision: f64) -> Vec<Region> {
arrangement(shapes, precision).map(|a| regions_of(&a)).unwrap_or_default()
}
+3
View File
@@ -60,6 +60,9 @@ pub(crate) struct Exporter<'a> {
images: HashMap<String, Option<Image>>,
/// `Some` while opacity mask art is written: whether an image in it was left out.
image_left_out: Option<bool>,
/// While the pieces of a distorted image whose opacity mask is its own pixel grid are written:
/// its image key and the image written with the mask as its alpha, which each piece draws.
piece_image: Option<(String, Image)>,
/// While the pieces of a mesh-warped image are written: the size its pixels are resampled for
/// ([`Exporter::warp_image_size`]).
warp_size: Option<images::SharedSize>,
+1
View File
@@ -35,6 +35,7 @@ impl<'a> Exporter<'a> {
warnings: vec![],
images: HashMap::new(),
image_left_out: None,
piece_image: None,
warp_size: None,
brushes: None,
knockout: doc.page_knockout,
+21 -5
View File
@@ -374,7 +374,8 @@ impl Exporter<'_> {
let (mut pushes, isolated_children) = transparency(s, n, page, container, knockout);
let mask = n.extras().mask.as_deref().filter(|m| !m.disabled);
let alpha = match (&n.kind, mask) {
(NodeKind::Image(im), Some(m)) => self.masked_image(im, m, !n.extras().pixelated),
// The mask's image shares the pixel grid only when it has the same corners (or none).
(NodeKind::Image(im), Some(m)) if n.image_quad() == m.art.image_quad() => self.masked_image(im, m, !n.extras().pixelated),
_ => None,
};
if let Some(m) = mask
@@ -427,7 +428,7 @@ impl Exporter<'_> {
self.shape(s, n, &bp, *rule, page);
}
NodeKind::Text(t) => self.text(s, n, t, page),
NodeKind::Image(im) => match (n.extras().colorize.as_deref(), self.doc.shown_image(n, im)) {
NodeKind::Image(im) if !n.is_distorted_image() => match (n.extras().colorize.as_deref(), self.doc.shown_image(n, im)) {
(Some(p @ Paint::Solid { .. }), im) if self.doc.image_blob(&im).is_none_or(vectorcraft_doc::ImageBlob::takes_colorize) => {
let im = &*im;
if writable(s, im.xf, Rect::new(0.0, 0.0, im.width.max(1).into(), im.height.max(1).into())) {
@@ -442,7 +443,11 @@ impl Exporter<'_> {
self.warn(super::exporter::UNWRITABLE_IMAGE);
}
}
(_, im) => self.image(s, &im, alpha, n.extras().pixelated),
(_, im) => {
// A piece of a distorted image draws the image its mask was written into.
let alpha = alpha.or_else(|| self.piece_image.as_ref().filter(|(key, _)| *key == im.key).map(|(_, i)| i.clone()));
self.image(s, &im, alpha, n.extras().pixelated)
}
},
NodeKind::SymbolInstance { symbol, xf } => {
// Within the objects a frame may draw of symbol instances, as on screen: nested
@@ -488,17 +493,28 @@ impl Exporter<'_> {
}
// A gradient mesh is a smooth patch shading where it can be written as one.
NodeKind::Mesh(m) if self.mesh(s, m) => {}
// Live blends/envelopes/meshes export their evaluated (expanded) form.
// Live blends/envelopes/meshes (and distorted images) export their evaluated
// (expanded) form.
NodeKind::Blend { .. }
| NodeKind::Envelope { .. }
| NodeKind::Mesh(_)
| NodeKind::Repeat(_)
| NodeKind::PlacedDocument(_)
| NodeKind::Intertwine { .. } => {
| NodeKind::Intertwine { .. }
| NodeKind::Image(_) => {
let g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);
// The pieces draw the image as it is shown, under its color mask's key.
let piece = match (&n.kind, &alpha) {
(NodeKind::Image(im), Some(img)) => Some((self.doc.shown_image(n, im).key.clone(), img.clone())),
_ => None,
};
let outer = piece.map(|p| self.piece_image.replace(p));
for c in g.children().into_iter().flatten() {
self.node(s, c, page, false);
}
if let Some(outer) = outer {
self.piece_image = outer;
}
}
// Ruler guides draw on screen only.
NodeKind::RulerGuide { .. } => {}
+37
View File
@@ -1173,6 +1173,43 @@ fn a_cmyk_image_masked_by_a_grey_image_of_its_grid_writes_it_as_its_smask() {
assert!(String::from_utf8_lossy(&bytes).contains("/S/Luminosity"), "a luminosity soft mask");
}
/// A distorted CMYK image whose mask is a gray image distorted to the same corners keeps the
/// mask on its pixel grid: every piece of its mesh draws the image with the mask as its `/SMask`,
/// with a color mask on the image too.
#[test]
fn a_distorted_cmyk_image_and_its_grid_mask_with_the_same_corners_write_it_as_its_smask() {
for color_masked in [false, true] {
let mut d = masked_doc(png(image::GrayImage::from_raw(2, 2, vec![255, 128, 0, 64]).unwrap()), true, false);
let q = [(16.0, 0.0), (24.0, 0.0), (40.0, 40.0), (0.0, 40.0)].map(|(x, y)| Point::new(x, y));
let id = d.layers[0].children().unwrap()[0].id;
let mut mask = d.node(id).unwrap().extras().mask.clone().unwrap();
Arc::make_mut(&mut mask.art).set_image_corners(q).unwrap();
if color_masked {
d.images.insert("shown".into(), ImageBlob::new("image/png", png(image::RgbaImage::from_pixel(2, 2, image::Rgba([0, 90, 200, 255])))));
}
let n = d.node_mut(id).unwrap();
n.extras_mut().mask = Some(mask);
if color_masked {
n.extras_mut().color_mask = Some(Box::new(vectorcraft_doc::color_mask::ColorMask {
key: "shown".into(),
from: "img".into(),
background: vectorcraft_doc::color_mask::MaskBackground::Colors,
colors: vec![[255, 255, 255]],
contiguous: false,
measure: vectorcraft_doc::color_mask::MaskMatch::Distance,
tolerance: 0.0,
softness: 0.0,
}));
}
n.set_image_corners(q).unwrap();
let (bytes, smasks) = export_smasks(&d);
// The shown pixels of a color mask have alpha, so its pieces take their triangles as
// luminosity masks; the mask's alpha still goes to the image's own `/SMask`.
assert!(color_masked || !String::from_utf8_lossy(&bytes).contains("/S/Luminosity"), "no luminosity soft mask");
assert!(!smasks.is_empty() && smasks.iter().all(|m| m.as_deref() == Some(&[255, 128, 0, 64][..])), "{color_masked}: {smasks:?}");
}
}
/// A grey mask image with a color mask masks the CMYK image with the pixels it shows: its hidden
/// pixels are clear in the image's `/SMask`.
#[test]
+42
View File
@@ -154,6 +154,48 @@ fn a_warped_image_is_written_once_for_all_its_pieces() {
}
}
/// An image changed by Perspective Distort is written as the pieces of its mesh, placed so that
/// its pixel rectangle's corners land on its corners: read back, each corner of the quad is a
/// corner of one of the pieces' images.
#[test]
fn a_distorted_image_is_written_with_its_corners_on_its_quad() {
let mut d = doc(encoded(colour(), ImageFormat::Png), "image/png");
let id = d.layers[0].children().unwrap()[0].id;
let q = [(40.0, 10.0), (60.0, 10.0), (90.0, 90.0), (10.0, 90.0)].map(|(x, y)| Point::new(x, y));
d.node_mut(id).unwrap().set_image_corners(q).unwrap();
let bytes = export_with_report(&d, &PdfOptions::default()).unwrap().bytes;
let back = crate::import(&bytes).unwrap();
let (mut seen, mut pieces) = ([false; 4], 0);
back.walk(|n| {
if let NodeKind::Image(im) = &n.kind {
pieces += 1;
let (w, h) = (f64::from(im.width), f64::from(im.height));
for p in [(0.0, 0.0), (w, 0.0), (w, h), (0.0, h)] {
let at = im.xf * Point::new(p.0, p.1);
for (i, c) in q.iter().enumerate() {
seen[i] |= at.distance(*c) < 0.01;
}
}
}
});
assert!(pieces > 2, "{pieces}");
assert_eq!(seen, [true; 4]);
// The pieces are clipped by the quad: a clipping path with its bounds and its area.
let mut quad_clips = 0;
back.walk(|n| {
if let NodeKind::Group { children, clip: true } = &n.kind
&& let Some(p) = children.first().and_then(|c| c.path_data())
&& let Some(b) = p.bounds()
{
let area: f64 = p.subpaths.iter().map(|s| s.area()).sum::<f64>().abs();
if [b.x0 - 10.0, b.y0 - 10.0, b.x1 - 90.0, b.y1 - 90.0].iter().all(|v| v.abs() < 0.01) && (area - 4000.0).abs() < 1.0 {
quad_clips += 1;
}
}
});
assert!(quad_clips >= 1, "no clipping path on the quad");
}
#[test]
fn jpeg_zip_and_automatic_compression() {
let png = doc(encoded(colour(), ImageFormat::Png), "image/png");
+5 -1
View File
@@ -325,7 +325,11 @@ fn encode_read_only_within(doc: &Document, n: &Node, symbols: &SymbolBoxes, left
o["truncated"] = json!(false);
}
NodeKind::Image(im) => {
o["transform"] = affine_json(im.xf);
// A distorted image: its corners, and the affine placement nearest them at its middle.
o["transform"] = affine_json(vectorcraft_doc::image_quad::nearest_affine(n).unwrap_or(im.xf));
if let Some(q) = n.image_quad() {
o["corners"] = json!(q.map(|p| [p.x, p.y]));
}
o["pixelSize"] = json!([im.width, im.height]);
o["colorMode"] = json!(doc.image_blob(im).map_or("unknown", color_mode));
o["linked"] = json!(im.link.is_some());
+18
View File
@@ -608,6 +608,24 @@ fn declared_embedded_and_linked_images_have_distinct_metadata_and_pixel_omission
}
}
/// A distorted image comes with its corners, and with the transform that matches it at its middle
/// rather than the one it had before the distort.
#[test]
fn a_distorted_image_comes_with_its_corners() {
let (mut d, _, _, [_, embedded, linked, ..]) = mixed();
let q = [(40.0, 60.0), (42.0, 60.0), (44.0, 62.0), (40.0, 62.0)].map(|(x, y)| Point::new(x, y));
d.node_mut(embedded).unwrap().set_image_corners(q).unwrap();
let e = encode_read_only(&d, d.node(embedded).unwrap()).unwrap();
assert_eq!(e["corners"], json!([[40.0, 60.0], [42.0, 60.0], [44.0, 62.0], [40.0, 62.0]]));
assert_ne!(e["transform"], json!([2.0, 0.0, 0.0, 2.0, 40.0, 60.0]));
// The transform is the affine map nearest the corners, the one that matches them at the middle.
let near = vectorcraft_doc::image_quad::nearest_affine(d.node(embedded).unwrap()).unwrap().as_coeffs();
let got: Vec<f64> = e["transform"].as_array().unwrap().iter().map(|v| v.as_f64().unwrap()).collect();
assert!(got.len() == 6 && got.iter().zip(near).all(|(a, b)| (a - b).abs() < 1e-9), "{got:?} against {near:?}");
let plain = encode_read_only(&d, d.node(linked).unwrap()).unwrap();
assert!(plain.get("corners").is_none());
}
/// A CMYK image's pixels are its inks as the working CMYK profile shows them on the canvas: black
/// ink alone is the profile's black, not RGB black.
#[test]
+35
View File
@@ -51,6 +51,8 @@ pub(crate) struct LiveCache {
expanded: FrameCache<usize, (Arc<Node>, Expanded, Found)>,
meshes: FrameCache<(usize, usize), MeshEntry>,
walks: FrameCache<usize, Walk>,
/// A distorted image's art by node and scale step ([`Renderer::distorted_art`]).
distorted: FrameCache<(usize, usize), (Arc<Node>, Arc<Node>)>,
/// How many live objects [`Renderer::live_expanded`] evaluated and how many meshes
/// [`Renderer::mesh_quads`] tessellated.
#[cfg(test)]
@@ -66,6 +68,7 @@ impl Default for LiveCache {
expanded: FrameCache::new(lru::LIVE_BUDGET, 256),
meshes: FrameCache::new(lru::MESH_BUDGET, 256),
walks: FrameCache::new(lru::WALK_BUDGET, 256),
distorted: FrameCache::new(lru::LIVE_BUDGET, 256),
#[cfg(test)]
evaluated: 0,
#[cfg(test)]
@@ -80,6 +83,7 @@ impl LiveCache {
self.expanded.sweep(stamp);
self.meshes.sweep(stamp);
self.walks.sweep(stamp);
self.distorted.sweep(stamp);
}
/// A cache whose evaluations take at most `budget` bytes.
@@ -522,6 +526,28 @@ impl Renderer {
v
}
/// Distorted image `a`'s art for drawing through `view`
/// ([`vectorcraft_doc::image_quad::distorted_art_at`] at the view's largest stretch, rounded to
/// a quarter of an octave), kept with `cache` while the node stays the same. `None` when `a` is
/// not a distorted image.
pub(crate) fn distorted_art(&mut self, a: &Arc<Node>, view: Affine, cache: bool) -> Option<Arc<Node>> {
let scale = vectorcraft_doc::image_quad::max_stretch(view);
let step = if scale.is_finite() && scale > 0.0 { (scale.log2() * 4.0).round().clamp(-256.0, 256.0) } else { 0.0 };
let key = (Arc::as_ptr(a) as usize, (step + 256.0) as usize);
if cache
&& let Some(e) = self.live.distorted.get(&key, self.stamp)
&& Arc::ptr_eq(&e.0, a)
{
return Some(e.1.clone());
}
let density = vectorcraft_doc::image_quad::Density::at_scale((step / 4.0).exp2());
let art = Arc::new(vectorcraft_doc::image_quad::distorted_art_at(a, density)?);
if cache {
self.live.distorted.insert(key, (a.clone(), art.clone()), lru::node_bytes(&art), self.stamp);
}
Some(art)
}
/// The quads of mesh `a` (`m`) at subdivision `level`, kept while the node and the color
/// settings that colored them ([`GradientMesh::color_at`]) stay the same.
fn mesh_quads(&mut self, doc: &Document, a: &Arc<Node>, m: &GradientMesh, level: usize, cache: bool) -> Arc<Vec<MeshQuad>> {
@@ -572,6 +598,15 @@ impl Renderer {
match &a.kind {
NodeKind::PlacedDocument(p) => self.draw_placed(ctx, f, p),
NodeKind::Mesh(m) => self.draw_mesh(ctx, f, a, m, cache),
// Outline mode draws a distorted image's frame through its corners, not the pieces it
// is drawn with.
NodeKind::Image(_) if f.opts.outline => self.draw_distorted_frame(ctx, f, a, cache),
// A distorted image's mesh is cut for the view's scale.
NodeKind::Image(_) => {
if let Some(art) = self.distorted_art(a, f.view, cache) {
self.draw_arc(ctx, f, &art);
}
}
NodeKind::Blend { .. }
| NodeKind::Envelope { .. }
| NodeKind::Repeat(_)
+46 -1
View File
@@ -2,6 +2,8 @@ use super::{
Affine, Arc, BezPath, Document, FillRule, Frame, HashMap, Ink, Node, NodeKind, Pixmap, Rect, RenderContext, Renderer, Shape, blob_key,
blob_pixmap, fill_rule, image_mip, ink, lookup, mip_level, peniko, proof, vello_cpu,
};
use vello_cpu::peniko::{BlendMode, Compose, Mix};
use crate::images;
/// The color image node `n` of `doc` is colorized with ([`vectorcraft_doc::NodeExtras::colorize`]),
@@ -24,6 +26,47 @@ impl Renderer {
self.draw_image_in(ctx, f, im, None, tint, false);
}
/// Distorted image `n` in outline mode: with Document Setup's Show Images in Outline Mode its
/// pixels, each piece of its mesh at the view's scale ([`Self::distorted_art`]) painted into
/// its triangle inside its corners, then its frame through its corners as a hairline. The
/// pieces knock out as the mesh's knockout group does ([`Self::draw_knockout`]): each first
/// erases the pieces below it inside its triangle, so a partly transparent image paints once
/// where pieces overlap.
pub(crate) fn draw_distorted_frame(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Arc<Node>, cache: bool) {
let frame = n.image_frame();
if f.doc.setup.outline_images
&& let Some(edge) = &frame
&& let Some(art) = self.distorted_art(n, f.view, cache)
{
let layer = |ctx: &mut RenderContext, compose: Compose| {
ctx.set_transform(Affine::IDENTITY);
ctx.push_layer(None, Some(BlendMode::new(Mix::Normal, compose)), None, None, None);
};
// The pieces along the edges reach past the corners: the corners clip them.
ctx.set_transform(f.view);
ctx.push_layer(Some(edge), Some(BlendMode::new(Mix::Normal, Compose::SrcOver)), None, None, None);
for piece in vectorcraft_doc::image_quad::distorted_pieces(&art) {
let Some([clip, image]) = piece.children().map(Vec::as_slice) else { continue };
let (NodeKind::Path { path, .. }, NodeKind::Image(im)) = (&clip.kind, &image.kind) else { continue };
let region = (path.to_bezpath(), FillRule::NonZero);
layer(ctx, Compose::DestOut);
ctx.set_transform(f.view);
ctx.set_paint(f.ink.fixed([255, 255, 255, 255]));
ctx.set_fill_rule(fill_rule(region.1));
ctx.fill_path(&region.0);
ctx.pop_layer();
layer(ctx, Compose::Plus);
let shown = f.doc.shown_image(image.as_ref(), im.as_ref());
self.draw_image_in(ctx, f, &shown, Some(&region), None, image.extras().pixelated);
ctx.pop_layer();
}
ctx.pop_layer();
}
if let Some(bp) = &frame {
self.hairline(ctx, f, bp, [0, 0, 0, 255]);
}
}
/// Draw an image, or with `area` (a region in the document inside the image's frame, see
/// [`plain_image`]) the image painted into that region; colorized with `tint` when given; with
/// `pixelated` ([`vectorcraft_doc::NodeExtras::pixelated`]) without smoothing.
@@ -136,7 +179,9 @@ impl Renderer {
} else if !pending && !outline {
self.image_left_out = self.image_left_out.map(|_| true);
}
if outline {
// An image painted into a region in outline mode is a piece of a distorted image, whose
// frame its caller draws ([`Self::draw_distorted_frame`]).
if outline && area.is_none() {
let mut p = rect.to_path(0.1);
p.apply_affine(im.xf);
self.hairline(ctx, f, &p, [0, 0, 0, 255]);
+7 -4
View File
@@ -251,6 +251,7 @@ impl Renderer {
&& !f.opts.outline
&& !self.is_shape(a)
&& let NodeKind::Image(im) = &a.kind
&& !a.is_distorted_image()
&& white_shape_mask(m)
&& let Some(region) = self.clip_of(&m.art)
&& shape_masked_image(a, im, &region.0)
@@ -370,7 +371,7 @@ impl Renderer {
self.stats.drawn += 1;
return;
}
if vectorcraft_doc::live::is_live(a) || effects::has_pathfinder(a) {
if vectorcraft_doc::live::is_drawn_live(a) || effects::has_pathfinder(a) {
// The isolated object itself (a repeat isolated to edit its source, #5054) draws its
// art as usual, as an isolated group does in `draw_layer_node`.
let settle = f.opts.isolated == Some(a.id) && f.doc.mask_edit.is_none();
@@ -525,6 +526,7 @@ impl Renderer {
// a clip layer (envelopes cut distorted images into many such pieces).
if let ([image], None, None) = (rest, &fill, &stroke)
&& let NodeKind::Image(im) = &image.kind
&& !image.is_distorted_image()
&& plain_image(image, im, &region.0)
{
let im = f.doc.shown_image(image, im);
@@ -578,7 +580,7 @@ impl Renderer {
}
}
NodeKind::Text(t) => self.draw_text(ctx, f, n, t),
NodeKind::Image(im) => {
NodeKind::Image(im) if !n.is_distorted_image() => {
self.draw_image_in(ctx, f, &f.doc.shown_image(n, im), None, images::image_tint(f.doc, n, f.ink), n.extras().pixelated)
}
NodeKind::SymbolInstance { symbol, xf } => {
@@ -604,7 +606,8 @@ impl Renderer {
| NodeKind::Mesh(_)
| NodeKind::Repeat(_)
| NodeKind::PlacedDocument(_)
| NodeKind::Intertwine { .. } => match self.live_root.clone().filter(|a| std::ptr::eq(&**a, n)) {
| NodeKind::Intertwine { .. }
| NodeKind::Image(_) => match self.live_root.clone().filter(|a| std::ptr::eq(&**a, n)) {
Some(a) => self.draw_live_body(ctx, f, &a, true),
None => self.draw_live_node(ctx, f, n),
},
@@ -629,7 +632,7 @@ impl Renderer {
/// same from frame to frame while the art does. When `a` is a live object,
/// [`Self::draw_content`] draws its evaluation from the live cache ([`Self::live_root`]).
pub(crate) fn draw_kept_node(&mut self, ctx: &mut RenderContext, f: &Frame, a: &Arc<Node>) {
let live = vectorcraft_doc::live::is_live(a).then(|| a.clone());
let live = vectorcraft_doc::live::is_drawn_live(a).then(|| a.clone());
let outer = std::mem::replace(&mut self.live_root, live);
self.draw_forced_arc(ctx, f, a);
self.live_root = outer;
+29
View File
@@ -605,6 +605,35 @@ fn outline_mode_no_fill() {
assert!(r.pixel(10, 50)[0] < 200);
}
/// Outline view draws a distorted image's frame through its corners: a slanted side, and nothing
/// inside or along the rectangle it was placed in.
#[test]
fn outline_mode_draws_a_distorted_images_frame_through_its_corners() {
let mut d = Document::new(100.0, 100.0);
let id = d.alloc_id();
let im = vectorcraft_doc::ImageObject {
key: "k".into(),
width: 10,
height: 10,
xf: Affine::scale(10.0),
link: None,
placement: Default::default(),
pixels: None,
};
let mut n = Node::new(id, NodeKind::Image(Box::new(im)));
let q = [(40.0, 0.0), (60.0, 0.0), (100.0, 100.0), (0.0, 100.0)].map(|(x, y)| vectorcraft_geom::Point::new(x, y));
n.set_image_corners(q).unwrap();
let l = d.layers[0].id;
d.insert(Some(l), 0, n).unwrap();
let r =
Renderer::new().render(&d, 100, 100, Affine::IDENTITY, &RenderOptions { outline: true, background: Some([255; 4]), ..Default::default() });
// On the left side, halfway down: from (40, 0) to (0, 100).
assert!(r.pixel(20, 50)[0] < 200, "the slanted side");
// The old rectangle's left edge and the inside of the quad stay blank.
assert_eq!(r.pixel(1, 30), [255; 4]);
assert_eq!(r.pixel(50, 50), [255; 4]);
}
/// A 100 × 100 document with each kind of path Outline view draws, and the ids of its objects by
/// name: a stroked square, a compound path with a hole, a path and a compound path with a live
/// effect, a guide, a clip group, an Image Trace object showing its outlines, and a path in a layer
+61
View File
@@ -136,3 +136,64 @@ fn other_clip_groups_in_a_knockout_group_knock_out_by_their_alpha() {
let a = r.pixel(120, 80)[3];
assert!(a > 160, "{a}");
}
/// Show Images in Outline Mode paints a half transparent distorted image's pixels once, where the
/// pieces of its mesh overlap too: inside the image, its alpha is the preview's.
#[test]
fn outline_mode_paints_a_distorted_images_pixels_once_where_its_pieces_overlap() {
let mut d = Document::new(100.0, 100.0);
d.images.insert("pic".into(), ImageBlob::png(png(128)));
d.setup.outline_images = true;
let im = ImageObject {
key: "pic".into(),
width: 4,
height: 4,
xf: Affine::translate((10.0, 10.0)) * Affine::scale(20.0),
link: None,
placement: Default::default(),
pixels: None,
};
let mut n = Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)));
n.set_image_corners([(20.0, 10.0), (80.0, 10.0), (90.0, 90.0), (10.0, 90.0)].map(|(x, y)| Point::new(x, y))).unwrap();
let pieces = vectorcraft_doc::image_quad::distorted_pieces(&vectorcraft_doc::image_quad::distorted_art(&n).unwrap()).len();
assert!(pieces > 2, "{pieces}");
d.insert(Some(d.layers[0].id), 0, n).unwrap();
let r = Renderer::new().render(&d, 400, 400, Affine::scale(4.0), &RenderOptions { outline: true, background: None, ..Default::default() });
let preview = drawn(&d);
let a = preview.pixel(200, 200)[3];
assert!(a.abs_diff(128) <= 4, "the image's own alpha inside it: {a}");
let mut off = vec![];
for y in 80..320 {
for x in 100..300 {
let (a, b) = (r.pixel(x, y)[3], preview.pixel(x, y)[3]);
if a.abs_diff(b) > 2 && off.len() < 8 {
off.push((x, y, a, b));
}
}
}
assert_eq!(off, vec![], "outline alpha against preview alpha");
}
/// The canvas cuts a distorted image's mesh for the view's scale: more pieces zoomed in, fewer
/// zoomed out, than the mesh files and print take.
#[test]
fn the_canvas_cuts_a_distorted_images_mesh_for_the_zoom() {
let im =
ImageObject { key: "pic".into(), width: 400, height: 400, xf: Affine::IDENTITY, link: None, placement: Default::default(), pixels: None };
let mut n = Node::new(vectorcraft_doc::NodeId(1), NodeKind::Image(Box::new(im)));
n.set_image_corners([(40.0, 0.0), (360.0, 0.0), (400.0, 400.0), (0.0, 400.0)].map(|(x, y)| Point::new(x, y))).unwrap();
let page = vectorcraft_doc::image_quad::distorted_pieces(&vectorcraft_doc::image_quad::distorted_art(&n).unwrap()).len();
let n = std::sync::Arc::new(n);
let mut r = Renderer::new();
let mut pieces = |scale: f64| vectorcraft_doc::image_quad::distorted_pieces(&r.distorted_art(&n, Affine::scale(scale), false).unwrap()).len();
let (small, large) = (pieces(1.0 / 25.0), pieces(8.0));
assert!(small < page && page < large, "{small} {page} {large}");
// A view that stretches one way and squeezes the other as much keeps its area, and still
// takes a finer mesh than an unscaled one.
let (plain, stretched) = (pieces(1.0), r_pieces(&n, Affine::scale_non_uniform(16.0, 1.0 / 16.0)));
assert!(stretched > plain, "{stretched} {plain}");
}
fn r_pieces(n: &std::sync::Arc<Node>, view: Affine) -> usize {
vectorcraft_doc::image_quad::distorted_pieces(&Renderer::new().distorted_art(n, view, false).unwrap()).len()
}
+59
View File
@@ -611,6 +611,65 @@ fn a_shadow_on_an_image_paints_offset_pixels() {
assert!(worst <= 4, "max channel difference {worst}");
}
/// A distorted opaque image is drawn opaque between its corners, where the pieces of its mesh
/// meet too; its drop shadow is the shape between its corners moved, and nothing paints where its
/// rectangle was.
#[test]
fn a_distorted_image_is_opaque_between_its_corners_and_its_shadow_follows_them() {
let mut d = image_doc(vec![fx("stylize.dropShadow", json!({"x": 10, "y": 10, "blur": 0, "opacity": 100, "mode": "normal"}))]);
let id = d.layers[0].children().unwrap()[0].id;
d.node_mut(id).unwrap().set_image_corners([(35.0, 20.0), (45.0, 20.0), (50.0, 50.0), (20.0, 50.0)].map(|(x, y)| Point::new(x, y))).unwrap();
let img = render(&d);
let mut faded = vec![];
for y in 30..42 {
for x in 30..40 {
let p = img.pixel(x, y);
// A seam shows the white page (green) or the shadow below (darker red) through.
if p[0] < 200 || p[1] > 48 {
faded.push((x, y, p));
}
}
}
assert_eq!(faded, vec![], "the image's red, also where its pieces meet");
assert!(lum(img.pixel(40, 55)) < 100, "the shadow below the quad: {:?}", img.pixel(40, 55));
assert_eq!(lum(img.pixel(24, 28)), WHITE, "outside the quad, inside the old rectangle");
// The rectangle's shadow would reach (58, 36); the quad's shadow ends at x = 56 there.
assert_eq!(lum(img.pixel(58, 36)), WHITE, "outside the quad's shadow, inside the rectangle's");
}
/// A distorted opaque image draws opaque inside its corners at any zoom, where the pieces of its
/// mesh meet too, and nothing of it draws outside its corners.
#[test]
fn a_distorted_image_is_opaque_inside_its_corners_at_every_zoom() {
let mut d = image_doc(vec![]);
let id = d.layers[0].children().unwrap()[0].id;
let q = [(35.0, 20.0), (45.0, 20.0), (50.0, 50.0), (20.0, 50.0)].map(|(x, y)| Point::new(x, y));
d.node_mut(id).unwrap().set_image_corners(q).unwrap();
for scale in [0.5, 1.0, 3.0] {
let size = (100.0 * scale) as u32;
let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
let img = Renderer::new().render(&d, size, size, Affine::scale(scale), &opts);
let at = |x: f64, y: f64| img.pixel((x * scale) as u32, (y * scale) as u32);
let mut faded = vec![];
// Points at least 2.5 pt inside the corners: the left side runs from (35, 20) to (20, 50)
// and the right side from (45, 20) to (50, 50).
for y in [24.0, 30.0, 36.0, 42.0, 47.0] {
let t = (y - 20.0) / 30.0;
let (left, right) = (35.0 - 15.0 * t + 2.5, 45.0 + 5.0 * t - 2.5);
let mid = (left + right) / 2.0;
for x in [left, (left + mid) / 2.0, mid, (mid + right) / 2.0, right] {
let p = at(x, y);
if p[1] > 12 || p[2] > 12 {
faded.push((x, y, p));
}
}
}
assert_eq!(faded, vec![], "the image's red at {scale}x");
assert_eq!(lum(at(24.0, 28.0)), WHITE, "outside the corners at {scale}x");
assert_eq!(lum(at(36.0, 17.0)), WHITE, "above the top edge at {scale}x");
}
}
#[test]
fn blur_on_a_symbol_instance_softens_its_edges() {
let plain = render(&symbol_doc(vec![]));
Loaded 100 of 175 files, more files were not shown because too many files have changed in this diff. Show more