mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-20 17:37:10 +01:00
Merge pull request #8392 from dotCooCoo/feat/distort-images
Free Transform: Perspective Distort and Free Distort put an image's corners on the handles
This commit is contained in:
84 files changed
+2666
-110
No files matched your search
+22
-8
@@ -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).
|
||||
|
||||
@@ -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)));
|
||||
|
||||
@@ -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()))
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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]);
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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};
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -650,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));
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
|
||||
@@ -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| {
|
||||
|
||||
@@ -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(),
|
||||
}))
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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};
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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, ¶ms).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();
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -67,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 =
|
||||
@@ -802,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).
|
||||
@@ -947,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.
|
||||
|
||||
@@ -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`).
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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 };
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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() });
|
||||
|
||||
@@ -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>,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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 { .. } => {}
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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());
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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(_)
|
||||
|
||||
@@ -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(®ion.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(®ion), 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]);
|
||||
|
||||
@@ -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, ®ion.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, ®ion.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;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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![]));
|
||||
|
||||
@@ -90,6 +90,7 @@ impl Reuse {
|
||||
| NodeKind::Repeat(_)
|
||||
| NodeKind::PlacedDocument(_)
|
||||
| NodeKind::Intertwine { .. } => (self.turns, self.scales) = (false, false),
|
||||
NodeKind::Image(_) if n.is_distorted_image() => (self.turns, self.scales) = (false, false),
|
||||
NodeKind::SymbolInstance { symbol, .. } => {
|
||||
// A scale reaching an instance of a symbol with 9-slice guides changes how its
|
||||
// cells are sized.
|
||||
@@ -988,7 +989,7 @@ impl Writer<'_> {
|
||||
self.shape(n, &d.join(" "), None, &paths, *rule, export_shape_bounds(n));
|
||||
}
|
||||
NodeKind::Text(t) => self.text_node(n, t),
|
||||
NodeKind::Image(im) => {
|
||||
NodeKind::Image(im) if !n.is_distorted_image() => {
|
||||
let shown = self.doc.shown_image(n, im);
|
||||
let im = &*shown;
|
||||
if let Some(Paint::Solid { color, .. }) = n.extras().colorize.as_deref()
|
||||
@@ -1090,14 +1091,28 @@ impl Writer<'_> {
|
||||
self.line("</g>");
|
||||
(self.xf, self.instance_xf) = saved;
|
||||
}
|
||||
// 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 { .. } => {
|
||||
let g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);
|
||||
| NodeKind::Intertwine { .. }
|
||||
| NodeKind::Image(_) => {
|
||||
let mut g = vectorcraft_effects::expand_live_deep(Some(self.doc), n);
|
||||
// A distorted image inside instances that scale it is cut as finely on the page as
|
||||
// one placed directly.
|
||||
let stretch = vectorcraft_doc::image_quad::max_stretch(self.instance_xf);
|
||||
if n.is_distorted_image()
|
||||
&& (stretch - 1.0).abs() > 1e-9
|
||||
&& let Some(art) = vectorcraft_doc::image_quad::distorted_art_at(n, vectorcraft_doc::image_quad::Density::page_at(stretch))
|
||||
&& let NodeKind::Group { children, .. } = &mut g.kind
|
||||
&& let [only] = &mut children[..]
|
||||
&& only.id == n.id
|
||||
{
|
||||
*only = std::sync::Arc::new(art);
|
||||
}
|
||||
self.share_images(&g);
|
||||
self.node_body(&g);
|
||||
}
|
||||
|
||||
@@ -167,6 +167,80 @@ fn hidden_warp_pieces_share_no_image() {
|
||||
}
|
||||
}
|
||||
|
||||
/// An image whose corners Perspective Distort moved is written with its pixels between those
|
||||
/// corners: opaque just inside each corner of the quad, and clear where its rectangle was but the
|
||||
/// quad is not.
|
||||
#[test]
|
||||
fn a_distorted_image_is_written_between_its_corners() {
|
||||
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));
|
||||
let mut d = Document::new(100.0, 100.0);
|
||||
let n = distorted_image(&mut d, q, 4);
|
||||
d.insert(d.default_layer(), 0, n).unwrap();
|
||||
let svg = export_full(&d, &ExportOptions::default(), None).svg;
|
||||
let tree = resvg::usvg::Tree::from_str(&svg, &resvg::usvg::Options::default()).unwrap();
|
||||
let mut pixmap = resvg::tiny_skia::Pixmap::new(400, 400).unwrap();
|
||||
resvg::render(&tree, resvg::tiny_skia::Transform::from_scale(4.0, 4.0), &mut pixmap.as_mut());
|
||||
let alpha = |x: f64, y: f64| pixmap.pixel((x * 4.0) as u32, (y * 4.0) as u32).unwrap().alpha();
|
||||
// A point (in points) 2 pt inside each corner, toward the quad's middle.
|
||||
let mid = Point::new(50.0, 50.0);
|
||||
for c in q {
|
||||
let inside = c + (mid - c).normalize() * 2.0;
|
||||
assert!(alpha(inside.x, inside.y) > 200, "{c:?}: {}", alpha(inside.x, inside.y));
|
||||
}
|
||||
// The rectangle's top corners lie outside the quad.
|
||||
assert_eq!(alpha(14.0, 14.0), 0);
|
||||
assert_eq!(alpha(86.0, 14.0), 0);
|
||||
}
|
||||
|
||||
/// A plain opaque red `px` × `px` image over (10, 10)–(90, 90), its corners moved to `q`.
|
||||
fn distorted_image(d: &mut Document, q: [Point; 4], px: u32) -> Node {
|
||||
let img = craft_image_codecs::Image::from_raw(
|
||||
px,
|
||||
px,
|
||||
craft_image_codecs::ChannelLayout::Rgba,
|
||||
craft_image_codecs::SampleType::U8,
|
||||
[255, 0, 0, 255].repeat((px * px) as usize),
|
||||
)
|
||||
.unwrap();
|
||||
let png = craft_image_codecs::encode(&img, craft_image_codecs::Format::Png, &craft_image_codecs::EncodeOptions::default()).unwrap();
|
||||
d.images.insert("pic".into(), ImageBlob::png(png));
|
||||
let im = ImageObject {
|
||||
key: "pic".into(),
|
||||
width: px,
|
||||
height: px,
|
||||
xf: Affine::translate((10.0, 10.0)) * Affine::scale(80.0 / f64::from(px)),
|
||||
link: None,
|
||||
placement: Default::default(),
|
||||
pixels: None,
|
||||
};
|
||||
let mut n = Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)));
|
||||
n.set_image_corners(q).unwrap();
|
||||
n
|
||||
}
|
||||
|
||||
/// A distorted image in a symbol instance that scales it is cut into as many pieces as the same
|
||||
/// image placed directly at that size.
|
||||
#[test]
|
||||
fn a_distorted_image_in_a_scaled_instance_is_cut_as_finely_as_one_placed_directly() {
|
||||
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));
|
||||
let pieces = |d: &Document| export_full(d, &ExportOptions::default(), None).svg.matches("<clipPath").count();
|
||||
let mut direct = Document::new(400.0, 400.0);
|
||||
let mut n = distorted_image(&mut direct, q, 64);
|
||||
n.transform(Affine::scale(4.0), false);
|
||||
direct.insert(direct.default_layer(), 0, n).unwrap();
|
||||
let in_instance = |scale: f64| {
|
||||
let mut d = Document::new(400.0, 400.0);
|
||||
let n = distorted_image(&mut d, q, 64);
|
||||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Pic".into(), art: std::sync::Arc::new(n) });
|
||||
let inst = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Pic".into(), xf: Affine::scale(scale) });
|
||||
d.insert(d.default_layer(), 0, inst).unwrap();
|
||||
d
|
||||
};
|
||||
let (want, unscaled, scaled) = (pieces(&direct), pieces(&in_instance(1.0)), pieces(&in_instance(4.0)));
|
||||
assert!(scaled > unscaled, "{scaled} {unscaled}");
|
||||
assert!(scaled.abs_diff(want) * 10 <= want, "{scaled} against {want}");
|
||||
}
|
||||
|
||||
/// Pieces of an opaque image are drawn one over another without knockout masks; a colorize paint
|
||||
/// draws a gray image's light pixels partly transparent, so its pieces take them.
|
||||
#[test]
|
||||
|
||||
@@ -479,10 +479,15 @@ fn renumber(doc: &mut Document, n: &mut Node) {
|
||||
/// as that pixel).
|
||||
fn image_color_at(s: &Sampler, n: &Node, p: Point) -> Option<Color> {
|
||||
let NodeKind::Image(im) = &n.kind else { return None };
|
||||
if im.xf.determinant().abs() < 1e-12 {
|
||||
return None;
|
||||
}
|
||||
let px = im.xf.inverse() * p;
|
||||
// A distorted image's pixel under `p` is found through its projective map.
|
||||
let px = if n.is_distorted_image() {
|
||||
n.image_map()?.inverse()?.apply(p)?
|
||||
} else {
|
||||
if im.xf.determinant().abs() < 1e-12 {
|
||||
return None;
|
||||
}
|
||||
im.xf.inverse() * p
|
||||
};
|
||||
let blob = s.doc.images.get(&im.key)?;
|
||||
let object = (im.width, im.height);
|
||||
if let Some(inks) = blob.sample_cmyk_object(px.x, px.y, object, s.raster_sample) {
|
||||
@@ -1050,6 +1055,12 @@ mod tests {
|
||||
assert_eq!(sampled_hex(&EyedropperTool::default().pointer(&crate::testutil::cx(&d, &s, &p), &click)), "#00ff00");
|
||||
d.node_mut(l).unwrap().visible = false;
|
||||
assert!(EyedropperTool::default().pointer(&crate::testutil::cx(&d, &s, &p), &click).is_empty());
|
||||
// Distorted with its left and right swapped, the blue pixel is drawn at the left.
|
||||
d.node_mut(l).unwrap().visible = true;
|
||||
let q = [(30.0, 0.0), (0.0, 0.0), (0.0, 10.0), (40.0, 10.0)].map(|(x, y)| vectorcraft_geom::Point::new(x, y));
|
||||
d.node_mut(id).unwrap().set_image_corners(q).unwrap();
|
||||
let left = PointerEvent::new(PointerKind::Down, 4.0, 5.0);
|
||||
assert_eq!(sampled_hex(&EyedropperTool::default().pointer(&crate::testutil::cx(&d, &s, &p), &left)), "#0000ff");
|
||||
}
|
||||
|
||||
/// #2276: a CMYK image gives its ink amounts as they are, not the RGB its decoder shows.
|
||||
|
||||
@@ -7144,6 +7144,10 @@ liquify-list-end {0}, {1} {0} i {1}
|
||||
@msg exit isolation mode first surt primer del mode d’aïllament
|
||||
@msg select an envelope selecciona un embolcall
|
||||
@msg select an image selecciona una imatge
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on l'objecte {_1} és una imatge modificada amb Distorsió de perspectiva o Distorsió lliure, amb la qual aquesta ordre no funciona
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape la imatge {_1} no es pot distorsionar així: les seves cantonades no formarien una forma convexa
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon la imatge {_1} no es pot distorsionar així: les seves cantonades creuarien l'horitzó de la distorsió
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map la imatge {_1} no es pot distorsionar així: les seves cantonades estarien massa juntes per a una projecció en perspectiva
|
||||
@msg `background` must be edges, corners or colors `background` ha de ser edges, corners o colors
|
||||
@msg `match` must be distance or channels `match` ha de ser distance o channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` ha d’estar entre 0 i 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5916,6 +5916,10 @@ liquify-list-end {0}, {1} {0} a {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset tato vektorizace by vytvořila více než {max} kotevních bodů, víc, než dokument plynule zobrazí: zvyšte Šum, snižte Cesty nebo Barvy, nebo zvolte přednastavení s nižší věrností
|
||||
@msg select an envelope vyberte obálku
|
||||
@msg select an image vyberte obraz
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on objekt {_1} je obraz změněný příkazem Perspektivní deformace nebo Volná deformace, se kterým tento příkaz nepracuje
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape obraz {_1} nelze takto deformovat: jeho rohy by netvořily konvexní tvar
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon obraz {_1} nelze takto deformovat: jeho rohy by překročily horizont deformace
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map obraz {_1} nelze takto deformovat: jeho rohy by byly příliš blízko sebe pro perspektivní zobrazení
|
||||
@msg `background` must be edges, corners or colors `background` musí být edges, corners nebo colors
|
||||
@msg `match` must be distance or channels `match` musí být distance nebo channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` musí být od 0 do 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -8086,6 +8086,10 @@ imageTrace Outline Kontur
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset denne sporing ville skabe flere end {max} ankerpunkter, hvilket er flere, end dokumentet kan vise flydende: hæv Støj, sænk Stier eller Farver, eller vælg en forudindstilling med lavere kvalitet
|
||||
@msg select an envelope markér en konvolut
|
||||
@msg select an image markér et billede
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on objektet {_1} er et billede, der er ændret med Perspektivforvrængning eller Fri forvrængning, og denne kommando virker ikke på det
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape billedet {_1} kan ikke forvrænges sådan: dets hjørner ville ikke danne en konveks form
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon billedet {_1} kan ikke forvrænges sådan: dets hjørner ville krydse forvrængningens horisont
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map billedet {_1} kan ikke forvrænges sådan: dets hjørner ville ligge for tæt på hinanden til en perspektivisk afbildning
|
||||
@msg select an object in perspective markér et objekt i perspektiv
|
||||
@msg select artwork (or a colour group) to recolor markér grafik (eller en farvegruppe) for at skifte farver
|
||||
@msg select at least two objects markér mindst to objekter
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5494,6 +5494,10 @@ liquify-list-end {0}, {1} {0} und {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset diese Nachzeichnung würde mehr als {max} Ankerpunkte erzeugen, mehr als das Dokument flüssig darstellen kann: Erhöhen Sie „Rauschen“, verringern Sie „Pfade“ oder „Farben“ oder wählen Sie eine Vorgabe mit geringerer Genauigkeit
|
||||
@msg select an envelope wählen Sie eine Hülle aus
|
||||
@msg select an image wählen Sie ein Bild aus
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on Objekt {_1} ist ein Bild, das mit Perspektivisch verzerren oder Frei verzerren verändert wurde; dieser Befehl funktioniert damit nicht
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape Bild {_1} kann so nicht verzerrt werden: seine Ecken würden keine konvexe Form bilden
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon Bild {_1} kann so nicht verzerrt werden: seine Ecken würden den Horizont der Verzerrung überschreiten
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map Bild {_1} kann so nicht verzerrt werden: seine Ecken lägen für eine perspektivische Abbildung zu nah beieinander
|
||||
@msg `background` must be edges, corners or colors `background` muss edges, corners oder colors sein
|
||||
@msg `match` must be distance or channels `match` muss distance oder channels sein
|
||||
@msg `{key}` must be from 0 to 100 `{key}` muss von 0 bis 100 sein
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5549,6 +5549,10 @@ digits Malayalam Μαλαγιάλαμ
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset αυτή η διανυσματοποίηση θα δημιουργούσε πάνω από {max} σημεία αγκύρωσης, περισσότερα από όσα μπορεί να εμφανίσει ομαλά το έγγραφο: αυξήστε τον Θόρυβο, μειώστε τις Διαδρομές ή τα Χρώματα ή επιλέξτε προεπιλογή χαμηλότερης πιστότητας
|
||||
@msg select an envelope επιλέξτε περίβλημα
|
||||
@msg select an image επιλέξτε εικόνα
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on το αντικείμενο {_1} είναι εικόνα που άλλαξε με Παραμόρφωση προοπτικής ή Ελεύθερη παραμόρφωση, στην οποία δεν λειτουργεί αυτή η εντολή
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape η εικόνα {_1} δεν μπορεί να παραμορφωθεί έτσι: οι γωνίες της δεν θα σχημάτιζαν κυρτό σχήμα
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon η εικόνα {_1} δεν μπορεί να παραμορφωθεί έτσι: οι γωνίες της θα περνούσαν τον ορίζοντα της παραμόρφωσης
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map η εικόνα {_1} δεν μπορεί να παραμορφωθεί έτσι: οι γωνίες της θα ήταν πολύ κοντά μεταξύ τους για προοπτική απεικόνιση
|
||||
@msg `background` must be edges, corners or colors το `background` πρέπει να είναι edges, corners ή colors
|
||||
@msg `match` must be distance or channels το `match` πρέπει να είναι distance ή channels
|
||||
@msg `{key}` must be from 0 to 100 το `{key}` πρέπει να είναι από 0 έως 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5609,6 +5609,10 @@ liquify-list-end {0}, {1} {0}, {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset este calco crearía más de {max} puntos de ancla, más de los que el documento puede mostrar con fluidez: sube Ruido, baja Trazados o Colores, o elige un preajuste de menor fidelidad
|
||||
@msg select an envelope selecciona una envolvente
|
||||
@msg select an image selecciona una imagen
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on el objeto {_1} es una imagen modificada con Distorsión de perspectiva o Distorsión libre, con la que este comando no funciona
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape la imagen {_1} no se puede distorsionar así: sus esquinas no formarían una forma convexa
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon la imagen {_1} no se puede distorsionar así: sus esquinas cruzarían el horizonte de la distorsión
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map la imagen {_1} no se puede distorsionar así: sus esquinas estarían demasiado juntas para una proyección en perspectiva
|
||||
@msg `background` must be edges, corners or colors `background` debe ser edges, corners o colors
|
||||
@msg `match` must be distance or channels `match` debe ser distance o channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` debe estar entre 0 y 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5832,6 +5832,10 @@ liquify-list-end {0}, {1} {0} ja {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset tämä jäljitys tuottaisi yli {max} ankkuripistettä, enemmän kuin asiakirja näyttää sujuvasti: nosta kohinaa, vähennä polkuja tai värejä tai valitse epätarkempi esiasetus
|
||||
@msg select an envelope valitse vääristyskuori
|
||||
@msg select an image valitse kuva
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on objekti {_1} on kuva, jota on muutettu Perspektiivivääristyksellä tai Vapaalla vääristyksellä, eikä tämä komento toimi sille
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape kuvaa {_1} ei voi vääristää näin: sen kulmat eivät muodostaisi kuperaa muotoa
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon kuvaa {_1} ei voi vääristää näin: sen kulmat ylittäisivät vääristyksen horisontin
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map kuvaa {_1} ei voi vääristää näin: sen kulmat olisivat liian lähellä toisiaan perspektiivikuvausta varten
|
||||
@msg `background` must be edges, corners or colors `background`-arvon on oltava edges, corners tai colors
|
||||
@msg `match` must be distance or channels `match`-arvon on oltava distance tai channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}`-arvon on oltava väliltä 0–100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5564,6 +5564,10 @@ liquify-list-end {0}, {1} {0} et {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset cette vectorisation créerait plus de {max} points d’ancrage, plus que le document ne peut afficher de façon fluide : augmentez Bruit, réduisez Tracés ou Couleurs, ou choisissez un paramètre prédéfini moins fidèle
|
||||
@msg select an envelope sélectionnez une enveloppe
|
||||
@msg select an image sélectionnez une image
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on l’objet {_1} est une image modifiée par Distorsion de perspective ou Distorsion manuelle, sur laquelle cette commande ne fonctionne pas
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape l’image {_1} ne peut pas être déformée ainsi, car ses coins ne formeraient pas une forme convexe
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon l’image {_1} ne peut pas être déformée ainsi, car ses coins franchiraient l’horizon de la déformation
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map l’image {_1} ne peut pas être déformée ainsi, car ses coins seraient trop proches pour une projection en perspective
|
||||
@msg `background` must be edges, corners or colors `background` doit valoir edges, corners ou colors
|
||||
@msg `match` must be distance or channels `match` doit valoir distance ou channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` doit être compris entre 0 et 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -8905,6 +8905,10 @@ liquify-list-end {0}, {1} {0} और {1}
|
||||
@msg select a text object एक टेक्स्ट ऑब्जेक्ट चुनें
|
||||
@msg select an envelope एक लिफाफे सिलेक्ट करें
|
||||
@msg select an image एक इमेज चुनें
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on ऑब्जेक्ट {_1} पर्सपेक्टिव या फ़्री डिस्टॉर्ट से बदली गई इमेज है, जिस पर यह कमांड काम नहीं करता
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape इमेज {_1} को इस तरह डिस्टॉर्ट नहीं किया जा सकता: इसके कोने उत्तल आकार नहीं बनाएँगे
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon इमेज {_1} को इस तरह डिस्टॉर्ट नहीं किया जा सकता: इसके कोने डिस्टॉर्ट के क्षितिज को पार कर जाएँगे
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map इमेज {_1} को इस तरह डिस्टॉर्ट नहीं किया जा सकता: इसके कोने पर्सपेक्टिव मैपिंग के लिए एक-दूसरे के बहुत पास होंगे
|
||||
@msg `background` must be edges, corners or colors `background` edges, corners या colors होना चाहिए
|
||||
@msg `match` must be distance or channels `match` distance या channels होना चाहिए
|
||||
@msg `{key}` must be from 0 to 100 `{key}` 0 से 100 तक होना चाहिए
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -6379,6 +6379,10 @@ liquify-list-end {0}, {1} {0} és {1}
|
||||
@msg a symbol can't hold an instance of itself egy szimbólum nem tartalmazhatja a saját példányát
|
||||
@msg select an envelope jelölj ki egy burkolót
|
||||
@msg select an image jelölj ki egy képet
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on ez a parancs nem működik Perspektivikus torzítással vagy Szabad torzítással módosított képen: {_1}
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape a kép nem torzítható így, mert a sarkai nem alkotnának konvex alakzatot: {_1}
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon a kép nem torzítható így, mert a sarkai átlépnék a torzítás horizontját: {_1}
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map a kép nem torzítható így, mert a sarkai túl közel lennének egymáshoz a perspektivikus leképezéshez: {_1}
|
||||
@msg `background` must be edges, corners or colors a `background` értéke edges, corners vagy colors lehet
|
||||
@msg `match` must be distance or channels a `match` értéke distance vagy channels lehet
|
||||
@msg `{key}` must be from 0 to 100 a `{key}` értéke 0 és 100 között lehet
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -9028,3 +9028,7 @@ file-filter Applications Aplikasi
|
||||
@msg the slices' descriptor has a reference of an unknown kind ({_1}) deskriptor irisan memiliki referensi dengan jenis yang tidak dikenal ({_1})
|
||||
@msg the slices' descriptor has a value of an unknown type ({_1}) deskriptor irisan memiliki nilai dengan tipe yang tidak dikenal ({_1})
|
||||
@msg the layers can't be read ({e}): the file was placed as its merged image lapisan tidak dapat dibaca ({e}): berkas ditempatkan sebagai gambar gabungannya
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on objek {_1} adalah gambar yang diubah dengan Distorsi perspektif atau Distorsi bebas, dan perintah ini tidak dapat digunakan padanya
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape gambar {_1} tidak dapat didistorsi dengan cara ini: sudut-sudutnya tidak akan membentuk bangun cembung
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon gambar {_1} tidak dapat didistorsi dengan cara ini: sudut-sudutnya akan melewati cakrawala distorsi
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map gambar {_1} tidak dapat didistorsi dengan cara ini: sudut-sudutnya terlalu berdekatan untuk pemetaan perspektif
|
||||
|
Can't render this file because it is too large.
|
@@ -5631,6 +5631,10 @@ liquify-list-end {0}, {1} {0} e {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset questo ricalco creerebbe più di {max} punti di ancoraggio, più di quanti il documento possa mostrare in modo fluido: aumenta Disturbo, riduci Tracciati o Colori, oppure scegli un preset a fedeltà inferiore
|
||||
@msg select an envelope seleziona un involucro
|
||||
@msg select an image seleziona un'immagine
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on l'oggetto {_1} è un'immagine modificata con Distorsione prospettica o Distorsione libera, su cui questo comando non funziona
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape l'immagine {_1} non può essere distorta così: i suoi angoli non formerebbero una forma convessa
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon l'immagine {_1} non può essere distorta così: i suoi angoli supererebbero l'orizzonte della distorsione
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map l'immagine {_1} non può essere distorta così: i suoi angoli sarebbero troppo vicini per una proiezione prospettica
|
||||
@msg `background` must be edges, corners or colors `background` deve essere edges, corners o colors
|
||||
@msg `match` must be distance or channels `match` deve essere distance o channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` deve essere compreso tra 0 e 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5685,6 +5685,10 @@ variable-list-end {0}, {1} {0}、{1}
|
||||
@msg no such view 指定された表示が見つかりません
|
||||
@msg printing isn't available here この環境ではプリントできません
|
||||
@msg select an image 画像を選択してください
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on オブジェクト {_1} は遠近変形または自由変形で変更された画像のため、このコマンドは使用できません
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape 角が凸形状にならないため、画像 {_1} はこのように変形できません
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon 角が変形の地平線を越えるため、画像 {_1} はこのように変形できません
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map 角が近すぎて遠近法で配置できないため、画像 {_1} はこのように変形できません
|
||||
@msg `background` must be edges, corners or colors `background` は edges、corners または colors にしてください
|
||||
@msg `match` must be distance or channels `match` は distance または channels にしてください
|
||||
@msg `{key}` must be from 0 to 100 `{key}` は 0 から 100 までの値にしてください
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -7348,6 +7348,10 @@ font-technology Variable ცვლადი
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset ეს ვექტორიზაცია {max}-ზე მეტ საყრდენ წერტილს შექმნიდა, რასაც დოკუმენტი შეუფერხებლად ვერ აჩვენებს: გაზარდეთ ხმაური, შეამცირეთ ტრაექტორიები ან ფერები, ან აირჩიეთ ნაკლები სიზუსტის პრესეტი
|
||||
@msg select an envelope მონიშნეთ გარსი
|
||||
@msg select an image მონიშნეთ გამოსახულება
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on ობიექტი {_1} არის პერსპექტიული დეფორმაციით ან თავისუფალი დეფორმაციით შეცვლილი გამოსახულება, რომელზეც ეს ბრძანება არ მუშაობს
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape გამოსახულება {_1} ასე ვერ დეფორმირდება: მისი კუთხეები ამოზნექილ ფორმას ვერ შექმნის
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon გამოსახულება {_1} ასე ვერ დეფორმირდება: მისი კუთხეები დეფორმაციის ჰორიზონტს გადაკვეთს
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map გამოსახულება {_1} ასე ვერ დეფორმირდება: მისი კუთხეები პერსპექტიული ასახვისთვის ერთმანეთთან ძალიან ახლოს იქნება
|
||||
@msg `background` must be edges, corners or colors `background` უნდა იყოს edges, corners ან colors
|
||||
@msg `match` must be distance or channels `match` უნდა იყოს distance ან channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` უნდა იყოს 0-დან 100-მდე
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5614,6 +5614,10 @@ variable-list-end {0}, {1} {0} 및 {1}
|
||||
@msg no such view 해당 보기가 없습니다
|
||||
@msg printing isn't available here 여기서는 인쇄할 수 없습니다
|
||||
@msg select an image 이미지를 선택하세요
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on 개체 {_1}은(는) 원근 왜곡 또는 자유 왜곡으로 변경된 이미지이므로 이 명령을 사용할 수 없습니다
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape 이미지 {_1}을(를) 이렇게 왜곡할 수 없습니다: 모서리가 볼록한 모양을 이루지 않습니다
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon 이미지 {_1}을(를) 이렇게 왜곡할 수 없습니다: 모서리가 왜곡의 지평선을 넘습니다
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map 이미지 {_1}을(를) 이렇게 왜곡할 수 없습니다: 모서리가 원근 매핑을 하기에 너무 가깝습니다
|
||||
@msg `background` must be edges, corners or colors `background`는 edges, corners 또는 colors여야 합니다
|
||||
@msg `match` must be distance or channels `match`는 distance 또는 channels여야 합니다
|
||||
@msg `{key}` must be from 0 to 100 `{key}`는 0에서 100 사이여야 합니다
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5962,6 +5962,10 @@ imageTrace Outline Contour
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset deze tracering zou meer dan {max} ankerpunten opleveren, meer dan het document vloeiend kan tonen: verhoog Ruis, verlaag Paden of Kleuren, of kies een voorinstelling met een lagere getrouwheid
|
||||
@msg select an envelope selecteer een omvorming
|
||||
@msg select an image selecteer een afbeelding
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on object {_1} is een afbeelding die met Perspectief vervormen of Vrij vervormen is gewijzigd, en deze opdracht werkt daar niet op
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape afbeelding {_1} kan niet zo worden vervormd: de hoeken zouden geen convexe vorm maken
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon afbeelding {_1} kan niet zo worden vervormd: de hoeken zouden de horizon van de vervorming overschrijden
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map afbeelding {_1} kan niet zo worden vervormd: de hoeken zouden te dicht bij elkaar liggen voor een perspectivische afbeelding
|
||||
@msg select an object in perspective selecteer een object in perspectief
|
||||
@msg select artwork (or a colour group) to recolor selecteer een illustratie (of een kleurgroep) om te herkleuren
|
||||
@msg select at least two objects selecteer minstens twee objecten
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5737,6 +5737,10 @@ liquify-list-end {0}, {1} {0} i {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset ten obrys utworzyłby ponad {max} punktów kontrolnych, więcej niż dokument może płynnie wyświetlić: zwiększ Szum, zmniejsz Ścieżki lub Kolory albo wybierz ustawienie o niższej wierności
|
||||
@msg select an envelope zaznacz kopertę
|
||||
@msg select an image zaznacz obraz
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on obiekt {_1} to obraz zmieniony przez Zniekształcenie perspektywiczne lub Swobodne zniekształcanie, na którym to polecenie nie działa
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape obrazu {_1} nie można tak zniekształcić: jego narożniki nie utworzyłyby kształtu wypukłego
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon obrazu {_1} nie można tak zniekształcić: jego narożniki przekroczyłyby horyzont zniekształcenia
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map obrazu {_1} nie można tak zniekształcić: jego narożniki byłyby zbyt blisko siebie dla odwzorowania perspektywicznego
|
||||
@msg `background` must be edges, corners or colors `background` musi mieć wartość edges, corners lub colors
|
||||
@msg `match` must be distance or channels `match` musi mieć wartość distance lub channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` musi mieścić się w zakresie od 0 do 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -4870,6 +4870,10 @@ axis Both Ambos
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset esta vetorização geraria mais de {max} pontos de ancoragem, mais do que o documento consegue exibir com fluidez: aumente Ruído, reduza Traçados ou Cores, ou escolha uma predefinição de menor fidelidade
|
||||
@msg select an envelope selecione um envelope
|
||||
@msg select an image selecione uma imagem
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on o objeto {_1} é uma imagem alterada por Distorção de Perspectiva ou Distorção Livre, com a qual este comando não funciona
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape a imagem {_1} não pode ser distorcida assim: seus cantos não formariam uma forma convexa
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon a imagem {_1} não pode ser distorcida assim: seus cantos cruzariam o horizonte da distorção
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map a imagem {_1} não pode ser distorcida assim: seus cantos ficariam próximos demais para um mapeamento em perspectiva
|
||||
@msg `background` must be edges, corners or colors `background` deve ser edges, corners ou colors
|
||||
@msg `match` must be distance or channels `match` deve ser distance ou channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` deve estar entre 0 e 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5629,6 +5629,10 @@ liquify-list-end {0}, {1} {0} и {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset эта трассировка создала бы более {max} опорных точек, что больше, чем документ может плавно отобразить: увеличьте «Шум», уменьшите «Контуры» или «Цвета» либо выберите набор с меньшей точностью
|
||||
@msg select an envelope выделите оболочку
|
||||
@msg select an image выделите изображение
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on объект {_1} — изображение, изменённое с помощью «Искажение перспективы» или «Свободная деформация», и эта команда с ним не работает
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape изображение {_1} нельзя так деформировать: его углы не образуют выпуклую фигуру
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon изображение {_1} нельзя так деформировать: его углы пересекут горизонт деформации
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map изображение {_1} нельзя так деформировать: его углы окажутся слишком близко друг к другу для перспективного отображения
|
||||
@msg `background` must be edges, corners or colors `background` должен быть edges, corners или colors
|
||||
@msg `match` must be distance or channels `match` должен быть distance или channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` должен быть от 0 до 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5483,6 +5483,10 @@ liquify-list-end {0}, {1} {0} och {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset spårningen skulle ge fler än {max} ankarpunkter, fler än dokumentet kan visa smidigt: höj Brus, sänk Banor eller Färger, eller välj en förinställning med lägre återgivning
|
||||
@msg select an envelope markera ett kuvert
|
||||
@msg select an image markera en bild
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on objekt {_1} är en bild som ändrats med Perspektivförvrängning eller Fri förvrängning, och det här kommandot fungerar inte på den
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape bild {_1} kan inte förvrängas så: dess hörn skulle inte bilda en konvex form
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon bild {_1} kan inte förvrängas så: dess hörn skulle korsa förvrängningens horisont
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map bild {_1} kan inte förvrängas så: dess hörn skulle ligga för nära varandra för en perspektivavbildning
|
||||
@msg `background` must be edges, corners or colors `background` måste vara edges, corners eller colors
|
||||
@msg `match` must be distance or channels `match` måste vara distance eller channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` måste vara från 0 till 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -570,6 +570,26 @@ fn objects_on_path_detach_strings_are_in_complete_catalogs() {
|
||||
}
|
||||
}
|
||||
|
||||
/// The errors of Perspective Distort and Free Distort on an image, and of the image commands that
|
||||
/// refuse a distorted image, are in every complete-message catalog.
|
||||
#[test]
|
||||
fn distorted_image_messages_are_in_complete_catalogs() {
|
||||
let literals = message_literals();
|
||||
for msg in [
|
||||
"object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on",
|
||||
"image {_1} cannot be distorted this way: its corners would not make a convex shape",
|
||||
"image {_1} cannot be distorted this way: its corners would cross the warp's horizon",
|
||||
"image {_1} cannot be distorted this way: its corners would be too close together for a perspective map",
|
||||
] {
|
||||
assert!(literals.contains(msg), "{msg}");
|
||||
let shown = msg.replace("{_1}", "7");
|
||||
for code in COMPLETE_MESSAGES {
|
||||
let lang = Lang::from_code(code).expect("registered");
|
||||
assert_ne!(message(lang, &shown), shown, "{code}: {msg}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// View › Proof Setup › Customize's labels.
|
||||
#[test]
|
||||
fn proof_setup_dialog_labels_are_in_complete_catalogs() {
|
||||
|
||||
@@ -5329,6 +5329,10 @@ liquify-list-end {0}, {1} {0} ve {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset bu iz, {max} bağlantı noktalarından daha fazlasını, yani belgenin düzgün bir şekilde gösterebileceğinden daha fazlasını oluşturur: Gürültüyü artırın, Yolları veya Renkleri düşürün veya aslına uygunluğu daha düşük bir ön ayar seçin
|
||||
@msg select an envelope bir zarf seç
|
||||
@msg select an image bir resim seç
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on {_1} nesnesi Perspektif Deformasyonu veya Serbest Deformasyon ile değiştirilmiş bir görüntüdür ve bu komut onunla çalışmaz
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape {_1} görüntüsü bu şekilde deforme edilemez: köşeleri dışbükey bir şekil oluşturmaz
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon {_1} görüntüsü bu şekilde deforme edilemez: köşeleri deformasyonun ufkunu geçer
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map {_1} görüntüsü bu şekilde deforme edilemez: köşeleri perspektif eşleme için birbirine çok yakın olur
|
||||
@msg `background` must be edges, corners or colors `background` edges, corners veya colors olmalıdır
|
||||
@msg `match` must be distance or channels `match` distance veya channels olmalıdır
|
||||
@msg `{key}` must be from 0 to 100 `{key}` 0 ile 100 arasında olmalıdır
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5615,6 +5615,10 @@ liquify-list-end {0}, {1} {0} і {1}
|
||||
@msg this trace would make more than {max} anchor points, more than the document can show smoothly: raise Noise, lower Paths or Colors, or pick a lower-fidelity preset це трасування створило б більше {max} опорних точок, що більше, ніж документ може плавно відобразити: збільште «Шум», зменште «Контури» або «Кольори» або виберіть набір з меншою точністю
|
||||
@msg select an envelope виділіть оболонку
|
||||
@msg select an image виділіть зображення
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on об’єкт {_1} — зображення, змінене за допомогою «Спотворення перспективи» або «Вільна деформація», і ця команда з ним не працює
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape зображення {_1} не можна так деформувати: його кути не утворять опуклої фігури
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon зображення {_1} не можна так деформувати: його кути перетнуть горизонт деформації
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map зображення {_1} не можна так деформувати: його кути будуть надто близько один до одного для перспективного відображення
|
||||
@msg `background` must be edges, corners or colors `background` має бути edges, corners або colors
|
||||
@msg `match` must be distance or channels `match` має бути distance або channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` має бути від 0 до 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -6081,6 +6081,10 @@ liquify-list-end {0}, {1} {0} và {1}
|
||||
@msg a symbol can't hold an instance of itself ký hiệu không thể chứa đối tượng của chính nó
|
||||
@msg select an envelope hãy chọn một Envelope
|
||||
@msg select an image hãy chọn ảnh
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on đối tượng {_1} là ảnh đã được thay đổi bằng Làm méo phối cảnh hoặc Làm méo tự do, lệnh này không dùng được với ảnh đó
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape không thể làm méo ảnh {_1} theo cách này: các góc của ảnh sẽ không tạo thành hình lồi
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon không thể làm méo ảnh {_1} theo cách này: các góc của ảnh sẽ vượt qua đường chân trời của phép làm méo
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map không thể làm méo ảnh {_1} theo cách này: các góc của ảnh sẽ quá gần nhau để ánh xạ phối cảnh
|
||||
@msg `background` must be edges, corners or colors `background` phải là edges, corners hoặc colors
|
||||
@msg `match` must be distance or channels `match` phải là distance hoặc channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` phải nằm trong khoảng 0 đến 100
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -5351,6 +5351,10 @@ imageTrace Outline 轮廓
|
||||
@msg no such view 没有此视图
|
||||
@msg printing isn't available here 此处无法打印
|
||||
@msg select an image 请选择一个图像
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on 对象 {_1} 是经过透视扭曲或自由变形的图像,此命令不适用于它
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape 无法这样扭曲图像 {_1}:其角点不会构成凸形
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon 无法这样扭曲图像 {_1}:其角点会越过扭曲的地平线
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map 无法这样扭曲图像 {_1}:其角点会太靠近,无法进行透视映射
|
||||
@msg `background` must be edges, corners or colors `background` 必须为 edges、corners 或 colors
|
||||
@msg `match` must be distance or channels `match` 必须为 distance 或 channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` 必须介于 0 到 100 之间
|
||||
|
||||
|
Can't render this file because it is too large.
|
@@ -2718,6 +2718,10 @@ file-filter Templates 範本
|
||||
@msg no such view 沒有這個檢視
|
||||
@msg printing isn't available here 此處無法列印
|
||||
@msg select an image 請選取影像
|
||||
@msg object {_1} is an image changed by Perspective Distort or Free Distort, which this command does not work on 物件 {_1} 是經過透視扭曲或隨意扭曲的影像,此指令無法用於它
|
||||
@msg image {_1} cannot be distorted this way: its corners would not make a convex shape 無法這樣扭曲影像 {_1}:其角點不會構成凸形
|
||||
@msg image {_1} cannot be distorted this way: its corners would cross the warp's horizon 無法這樣扭曲影像 {_1}:其角點會越過扭曲的地平線
|
||||
@msg image {_1} cannot be distorted this way: its corners would be too close together for a perspective map 無法這樣扭曲影像 {_1}:其角點會太靠近,無法進行透視對應
|
||||
@msg `background` must be edges, corners or colors `background` 必須為 edges、corners 或 colors
|
||||
@msg `match` must be distance or channels `match` 必須為 distance 或 channels
|
||||
@msg `{key}` must be from 0 to 100 `{key}` 必須介於 0 到 100 之間
|
||||
|
||||
|
Can't render this file because it is too large.
|
+41
@@ -7376,6 +7376,47 @@ warped (`from`, or the selection's bounds) change nothing and add no undo step.
|
||||
{"name":"run_command","arguments":{"command":"object.distort","params":{"from":[-100,0,0,100],"angle":90,"corners":[[0,100],[0,0],[120,-20],[100,100]]}}}
|
||||
```
|
||||
|
||||
## Perspective Distort and Free Distort on images
|
||||
|
||||
`object.distort` moves an image's four corners exactly where the warp takes them, alone or with other objects, and
|
||||
draws its pixels in perspective between them. The image is bounded, selected and clicked by the shape its corners
|
||||
make, and moving, scaling, rotating or shearing it later, or a Transform effect on it, takes the corners along.
|
||||
Outline view draws its frame through the corners. Blends, the Eyedropper, the Color Theme Picker of Recolor Artwork
|
||||
and the weed box of Weed Box and Lines (`addon.cutting.weed`) read the image where its corners put it. When the
|
||||
corners make a parallelogram, the image is placed by its transform as before. Otherwise the native file saves them in
|
||||
the image's `image_quad` field (top left, top right, bottom right and bottom left of its pixels, in page
|
||||
coordinates); files without the field open as before. The canvas, printing and every export except DXF, WMF and HP-GL
|
||||
(an HP-GL plot leaves images out) draw a distorted image as a mesh of affine image pieces, clipped by the corners; no warped copy of the pixels is stored. In
|
||||
printing and exports the mesh takes as many cells as it needs for the pieces to stay within 0.05 pt of the exact
|
||||
perspective at the points it checks, with cells at least 2 pt long on the corners' longest side, and each piece reaches
|
||||
0.5 pt into its neighbors. The canvas cuts the mesh for the zoom, by the view's largest stretch: within a quarter of a
|
||||
screen pixel at the points it checks, with cells at least 4 pixels long, and each piece reaches 2 pixels into its
|
||||
neighbors. Either way the mesh takes no more than 64 by 64 cells, and no more cells across than the image has pixels on
|
||||
its longer side (or 8, if that is more). A stronger perspective, or a smaller image, is drawn with the cells it is
|
||||
allowed. In EMF each piece stores only the pixels inside its clip, with a pixel more on each side. DXF and WMF cannot
|
||||
clip, so they write the image as the parallelogram nearest its corners and warn. Corners that would fold the image over
|
||||
itself, put three corners on one line, join two corners, cross the warp's horizon or lie too close together for a
|
||||
perspective map are an error, and nothing changes. A transform that squeezes the corners past what a perspective map
|
||||
can place leaves the image at the parallelogram nearest them. A file whose `image_quad` holds other than four points,
|
||||
or breaks these rules, opens with the image placed by its transform. A drag is one undo step, and a distort that leaves
|
||||
the corners where they are records none. Image info (`image.info`) gives a distorted image's resolution at its middle, and Link
|
||||
Info (`links.info`) gives its scale and rotation there.
|
||||
|
||||
Crop Image (`object.cropImage`), Image Trace (`imageTrace.make`, `imageTrace.makeAndExpand`), Relink (`links.relink`),
|
||||
Embed (`links.embed`), Unembed (`links.unembed`), Create Object Mosaic (`object.createObjectMosaic`) and Place with
|
||||
Replace (`file.place` with `replace`) of anything but a text file refuse a distorted image with an error that names the
|
||||
distortion; Place with Replace does not refuse a clipping group that holds a distorted image of a DCS file's plates. Relink and Unembed refuse a named or selected distorted image before they search a folder or write a file.
|
||||
Create Gradient Mesh (`object.mesh.create`) converts the other objects it is given and lists each distorted image it
|
||||
leaves as it is in `skipped`, with its `id` and the error as `reason`; with nothing else to convert, it returns that
|
||||
error. Update Links (`links.update`) puts a changed file's pixels between a distorted
|
||||
image's corners, without applying its Placement Options. Mask (`object.maskImage`) draws its clipping path through the
|
||||
image's corners. Rasterize (`object.rasterize`) draws the image between its corners and makes a plain image of the
|
||||
result. These rules are VectorCraft's own.
|
||||
|
||||
```json
|
||||
{"name":"run_command","arguments":{"command":"object.distort","params":{"corners":[[40,0],[60,0],[100,100],[0,100]]}}}
|
||||
```
|
||||
|
||||
## Transform Each: Relative and Absolute
|
||||
|
||||
`object.transformEach` scales by percentages of each object's size (the dialog's Relative, the default), or with
|
||||
|
||||
+4
-1
@@ -678,7 +678,10 @@ every attribute:
|
||||
of JSON: type whose runs and paragraphs don't fit what the type before it in paint order left comes with
|
||||
`truncated: true` too.
|
||||
- An image (`"image"`): `pixelSize` is its width and height in pixels; `colorMode` is `"rgb"`, `"cmyk"`, `"gray"` or
|
||||
`"unknown"`, read from the image itself. An embedded image whose pixels take at most 1 MiB in base64 (443 × 443
|
||||
`"unknown"`, read from the image itself. An image whose corners Perspective Distort or Free Distort moved to a shape
|
||||
that is not a parallelogram also has `corners`, its pixel rectangle's corners on the page (top left, top right,
|
||||
bottom right, bottom left), and its `transform` is then the affine placement nearest them, the one that matches the
|
||||
perspective at the middle of its pixels. An embedded image whose pixels take at most 1 MiB in base64 (443 × 443
|
||||
pixels fit) has them in `pixelsBase64`: straight RGBA, 8 bits a channel, row by row from the top, and
|
||||
`pixelsOmitted: false`. A CMYK image's pixels are its inks through the working CMYK profile, as sRGB. The pixels of
|
||||
all the images in one input take at most 16 MiB in base64, and an image the host starts to decode takes its size
|
||||
|
||||
@@ -1175,6 +1175,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
|
||||
- After a rotation the Scale and Reflect tools, the Scale and Reflect dialogs, `object.scale`, `object.reflect` with a named axis and the Transform and Properties panels' flips act along the selection's turned bounding box until Reset Bounding Box: the horizontal and vertical scale stretch along its own width and height, and the vertical and horizontal reflection axes are its own. The Reflect tool's default axis and its Shift steps start from the box's axes, and an axis drawn with the tool is the line drawn on the page. `basis: "page"` keeps the page's axes (VectorCraft's own rules; `bboxrotate::scale_and_reflect_follow_the_turned_box`, tools `xform::transform::tests::scale_and_reflect_drags_follow_a_turned_bounding_box`).
|
||||
- The Reflect tool sets an axis with two clicks: a click sets the first point (and the reference point), and a second click reflects the selection across the line through both points as one undo step; Alt/Option on the second click reflects a copy, and a drag after the first click draws the axis from it ([the help page](https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/reflect-or-flip-objects.html)). A dashed line runs from the first point to the pointer until the second click. VectorCraft's own rules: an Alt-click opens the dialog and sets no axis; a second click whose snapped point is within 3 screen pixels of the first point's snapped point does nothing and the axis keeps waiting; Shift does not constrain a plain second click; Escape, Enter, a changed selection, an edit made outside the tool or another tool drops the waiting axis. A double-click arrives as two clicks: its first click is the second point, so a double-click away from the first point reflects the selection, and the double-click then opens the dialog with no axis waiting (tools `xform::transform::tests::a_second_reflect_click_reflects_across_the_line_through_both_points` and the four tests after it; engine `xform::two_reflect_clicks_reflect_across_their_line_as_one_undo_step`).
|
||||
- Perspective Distort and Free Distort (`object.distort`) turn each warped object's bounding box as the warp turns the object at its own center, the objects inside groups, compound paths and clip groups and the art of linked opacity masks included, so the next Selection or Free Transform drag uses the tilted box; Object › Transform › Reset Bounding Box squares it again, and corners left where they are add no undo step (VectorCraft's own rule; `bboxrotate::distort_turns_an_upright_box_with_the_warp_at_its_center`, `distort_turns_each_member_and_linked_mask_by_its_own_warp`, `mirrored_and_collapsing_distorts_keep_valid_angles`, `distort_angles_undo_redo_and_reopen_together`, `xform::unchanged_distort_records_no_history`).
|
||||
- Perspective Distort and Free Distort (`object.distort`) move an image's four corners exactly onto the handles when the image is distorted alone; with other objects the handles stand for the whole selection, and the image's corners follow the same warp without necessarily landing on them. The image's pixels are drawn in perspective between its corners on the canvas, in print and in every export that holds images, as a mesh of affine image pieces (DXF and WMF write the nearest parallelogram and warn; HP-GL plots leave images out); the native file saves the corners; bounds, clicks, blends, the Eyedropper, Outline view, the Color Theme Picker and Weed Box and Lines follow them; Image info and Link Info measure the image at its middle; and corners that would fold the image over, fall on one line, cross the warp's horizon or lie too close together for a perspective map are refused. Crop Image, Image Trace, Relink, Embed, Unembed, Create Object Mosaic, Create Gradient Mesh and Place with Replace refuse a distorted image (Place with Replace refuses only when the object it measures is the distorted image, so it does not refuse when the placed file is text or the replaced object is a DCS file's plates); Update Links puts a changed file's pixels between its corners; Rasterize makes a plain image of it. All of this is VectorCraft's own rule (doc `image_quad::tests`, `blend::tests::steps_between_distorted_images_have_corners_between_theirs`; engine `xform::distort_puts_an_images_corners_on_the_handles`, `distort_moves_an_image_and_a_path_as_one`, `distort_refuses_a_folded_image_and_crop_and_trace_refuse_a_distorted_one`, `distort_names_the_horizon_and_an_unchanged_distort_of_a_distorted_image_records_nothing`, `distort_of_a_blend_holding_an_image_is_not_refused`, `free_transform_distort_drag_on_an_image_is_one_undo_step`, `mask_on_a_distorted_image_follows_its_corners`, `a_transform_effect_moves_a_distorted_images_corners`, `a_transform_after_a_warp_moves_a_distorted_image_once`, `baked_raster_effect_pixels_replace_a_distortion`, `rasterize_draws_a_distorted_image_between_its_corners`, `image_info_measures_a_distorted_image_at_its_middle`, `a_distorted_image_saves_and_reads_back`, `links::update_links_keeps_a_distorted_images_corners`, `recolor::theme_picker_reads_a_distorted_image_where_it_is_drawn`, `addons::cutting::weed::tests::a_distorted_image_is_measured_by_the_frame_through_its_corners`; render `outline_mode_draws_a_distorted_images_frame_through_its_corners`, `meshwarp::outline_mode_paints_a_distorted_images_pixels_once_where_its_pieces_overlap`, `meshwarp::the_canvas_cuts_a_distorted_images_mesh_for_the_zoom`, `objectfx::a_distorted_image_is_opaque_between_its_corners_and_its_shadow_follows_them`, `objectfx::a_distorted_image_is_opaque_inside_its_corners_at_every_zoom`; svg `warp_pieces::a_distorted_image_is_written_between_its_corners`; pdf `compression::a_distorted_image_is_written_with_its_corners_on_its_quad`; eps `a_distorted_image_is_written_with_its_corners_on_its_quad`; cad `a_distorted_image_is_written_as_its_nearest_parallelogram_with_a_warning`; metafile `a_distorted_image_is_its_mesh_with_clips_and_its_nearest_parallelogram_without`; tools `xform::eyedropper::tests::clicking_an_image_samples_its_pixels`; plugins `objects::tests::a_distorted_image_comes_with_its_corners`; ui-egui `i18n::tests::distorted_image_messages_are_in_complete_catalogs`).
|
||||
- The Free Transform widget's Constrain works in Free Distort as well as in Free Transform ([the help page](https://helpx.adobe.com/illustrator/using/tool-techniques/free-transform-tool.html)). With Constrain on, or Shift held, a corner dragged in Free Distort moves only along the line through the opposite corner, in the box's own proportions, and the other three corners stay in place; on a turned box the line runs through the box's own corners. The line is VectorCraft's own rule. Cmd/Ctrl+Alt+Shift on a corner still drags in Perspective Distort, where Constrain stays unavailable (tools `xform::free::tests::free_distort_corner_keeps_to_its_diagonal_with_shift_or_constrain`, `shift_pressed_during_a_free_distort_drag_constrains_it`, `a_turned_box_is_constrained_along_its_own_diagonal`, `along_diagonal_of_a_degenerate_box`; engine `xform::free_transform_constrained_distort_keeps_the_corner_on_its_diagonal`; ui-egui `free_transform::tests::the_widget_sets_the_mode_and_a_corner_drag_then_distorts`).
|
||||
- With Smart Guides › Transform Tools on, a Free Transform shear (Cmd/Ctrl on a side handle) shows its angle next to the pointer, as the Shear tool does, and a handle drag that turns from a scale into a shear and back shows only the current operation's value ([the help page](https://helpx.adobe.com/illustrator/desktop/measure-and-align/grids-and-guides/smart-guides-options.html)). The angle's sign and its one decimal place are VectorCraft's own rule, the same as the Shear tool's label (tools `xform::free::tests::shear_drag_shows_its_angle_with_transform_tools_guides`, `a_handle_drag_that_changes_operation_relabels_it`).
|
||||
- Native macOS menu bar, vector tool cursors, a command palette (Help › Search Commands…), middle-button panning with any tool. Native menus explicitly end tracking on command selection, outside window presses and Escape; menu updates wait until tracking ends, and a dismissing press never starts a canvas gesture (M14.8).
|
||||
|
||||
Reference in new issue
Block a user