mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 12:38:18 +00:00
Merge main into perf/layer-select-all-one-pass
This commit is contained in:
@@ -147,7 +147,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Add Points at Crossings",
|
||||
["Object", "Plug-ins", "Path Precision Tools"],
|
||||
None,
|
||||
"{cut?: bool (false: add anchors where the paths cross; true: also cut them there), selfCrossings?: bool (false: where a path crosses itself too, a curved segment that loops over itself included), ids?: [id…] (default: the selection)} where the paths under the objects cross one another, as one undo step; at most 10000 segments → {ids, crossings (anchors placed)}",
|
||||
"{cut?: bool (false: add anchors where the paths cross; true: also cut them there), selfCrossings?: bool (false: where a path crosses itself too, a curved segment that loops over itself included), ids?: [id…] (default: the selection)} where the paths under the objects cross one another, an open end that lies within 0.001 pt of another path counting as crossing it there, as one undo step; at most 10000 segments → {ids, crossings (anchors placed)}",
|
||||
has_selection,
|
||||
crossings
|
||||
),
|
||||
|
||||
@@ -4,6 +4,8 @@
|
||||
//! be edited, selected or not. What it removes is worked out by
|
||||
//! [`vectorcraft_tools::addons::trim::plan`], which the tool also uses to show it beforehand.
|
||||
|
||||
use std::collections::HashSet;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::{NodeId, NodeKind};
|
||||
use vectorcraft_geom::{Point, Rect};
|
||||
@@ -33,7 +35,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
|
||||
"Trim at Crossings",
|
||||
[],
|
||||
None,
|
||||
"{at: [x, y], tolerance?: pt 0..100 (3; how near `at` a path counts as under it)} or {rect: [x, y, width, height]} or {points: [[x, y]…] (2 to 100000 points)} remove stretches of paths, a stretch running between two neighboring places where the path is crossed by another path or by itself, or from such a place to an open end: `at` removes the stretch of the nearest path at that point, `rect` every stretch the rectangle touches, `points` every stretch the line through the points crosses. Give exactly one of the three. Every path that can be edited takes part, selected or not, compound path members included; hidden and locked paths, guides and clipping paths (compound ones' members included) are neither trimmed nor counted as crossing; in isolation mode only paths inside the isolated object are trimmed. A path that ends on another marks a place on the other; paths that lie along each other don't cross. A closed path that loses a stretch becomes open, an open path that loses a middle stretch becomes two paths with its appearance in its place in the stacking order, and a path nothing crosses is removed whole; a live shape becomes a plain path. One undo step, none when nothing is removed → {ids (the paths left of those trimmed), removed (stretches)}",
|
||||
"{at: [x, y], tolerance?: pt 0..100 (3; how near `at` a path counts as under it)} or {rect: [x, y, width, height]} or {points: [[x, y]…] (2 to 100000 points)} remove stretches of paths, a stretch running between two neighboring places where the path is crossed by another path or by itself, or from such a place to an open end: `at` removes the stretch of the nearest path at that point, `rect` every stretch the rectangle touches, `points` every stretch the line through the points crosses. Give exactly one of the three. Every path that can be edited takes part, selected or not, compound path members included; hidden and locked paths, guides and clipping paths (compound ones' members included) are neither trimmed nor counted as crossing; in isolation mode only paths inside the isolated object are trimmed. A path that ends on another, or within 0.001 pt of it, marks a place on the other; paths that lie along each other don't cross. A closed path that loses a stretch becomes open, an open path that loses a middle stretch becomes two paths with its appearance in its place in the stacking order, and a path nothing crosses is removed whole; a live shape becomes a plain path. One undo step, none when nothing is removed → {ids (the paths left of those trimmed), removed (stretches)}",
|
||||
has_doc,
|
||||
trim
|
||||
)]
|
||||
@@ -100,20 +102,21 @@ fn trim(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
compounds.dedup();
|
||||
let mut beside = Beside::replacing(d, &trimmed);
|
||||
let mut all = vec![];
|
||||
// The selection is read through a set and changed once at the end, so a trim of many
|
||||
// paths does not go through the selected objects once per path and per piece.
|
||||
let mut selected_ids: HashSet<NodeId> = sel.objects.iter().copied().collect();
|
||||
let mut joining: Vec<NodeId> = vec![];
|
||||
let mut gone: Vec<NodeId> = vec![];
|
||||
for (id, pieces) in plan {
|
||||
let selected = sel.contains(id);
|
||||
let selected = selected_ids.contains(&id);
|
||||
sel.anchors.remove(&id);
|
||||
sel.segments.remove(&id);
|
||||
let made = replace_with_pieces(d, &mut beside, id, pieces)?;
|
||||
// The pieces of a selected path are selected; what was not selected stays so.
|
||||
if made.is_empty() {
|
||||
sel.remove(id);
|
||||
gone.push(id);
|
||||
} else if selected {
|
||||
for n in &made {
|
||||
if !sel.contains(*n) {
|
||||
sel.add(*n);
|
||||
}
|
||||
}
|
||||
joining.extend(made.iter().copied().filter(|n| selected_ids.insert(*n)));
|
||||
}
|
||||
all.extend(made);
|
||||
}
|
||||
@@ -121,9 +124,15 @@ fn trim(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
for c in compounds {
|
||||
if d.node(c).is_some_and(|n| n.children().is_some_and(|ch| ch.is_empty())) {
|
||||
d.remove(c)?;
|
||||
sel.remove(c);
|
||||
gone.push(c);
|
||||
}
|
||||
}
|
||||
sel.remove_all(gone);
|
||||
if let Some((first, rest)) = joining.split_first() {
|
||||
// `add` clears what any change to the object selection clears; the rest are new ids.
|
||||
sel.add(*first);
|
||||
sel.objects.extend_from_slice(rest);
|
||||
}
|
||||
Ok(all)
|
||||
})?;
|
||||
Ok(json!({ "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "removed": removed }))
|
||||
|
||||
@@ -2,8 +2,9 @@
|
||||
//! one undo step, and what takes no part.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::{NodeId, NodeKind};
|
||||
use vectorcraft_doc::{NodeId, NodeKind, Selection};
|
||||
use vectorcraft_geom::{PathData, Point};
|
||||
use vectorcraft_tools::addons::trim::plan::{self, Limits, Stretches};
|
||||
|
||||
use crate::Session;
|
||||
|
||||
@@ -420,6 +421,139 @@ fn the_selection_stays_as_it_was_and_the_pieces_of_a_selected_path_are_selected(
|
||||
assert!(s.doc().unwrap().selection.is_empty(), "a removed path leaves the selection");
|
||||
}
|
||||
|
||||
/// Run the command with `p`, and check that it leaves the selection exactly as changing it one
|
||||
/// id at a time does: for each trimmed path in the plan's order, its anchors and segments let go,
|
||||
/// a path with no pieces left removed, and each piece of a selected path added; then each emptied
|
||||
/// compound path removed. Returns the selection.
|
||||
fn same_selection_as_one_id_at_a_time(s: &mut Session, p: Value) -> Selection {
|
||||
let st = s.doc().unwrap();
|
||||
let pick = super::pick(&p).unwrap();
|
||||
let root = crate::cmd::ordinary_isolation(st);
|
||||
let plan: Vec<(NodeId, usize)> =
|
||||
plan::plan(&st.doc, root, &pick, Limits::COMMAND, &mut Stretches::default()).unwrap().into_iter().map(|t| (t.id, t.pieces.len())).collect();
|
||||
let mut compounds: Vec<NodeId> = plan
|
||||
.iter()
|
||||
.filter_map(|(id, _)| st.doc.parent_of(*id))
|
||||
.filter(|c| matches!(st.doc.node(*c).map(|n| &n.kind), Some(NodeKind::Compound { .. })))
|
||||
.collect();
|
||||
compounds.dedup();
|
||||
let mut want = st.selection.clone();
|
||||
let made = ids(&s.execute(TRIM, &p).unwrap());
|
||||
assert_eq!(made.len(), plan.iter().map(|(_, n)| n).sum::<usize>());
|
||||
let mut made = made.into_iter();
|
||||
for (id, n) in plan {
|
||||
let selected = want.contains(id);
|
||||
want.anchors.remove(&id);
|
||||
want.segments.remove(&id);
|
||||
let pieces: Vec<NodeId> = made.by_ref().take(n).collect();
|
||||
if pieces.is_empty() {
|
||||
want.remove(id);
|
||||
} else if selected {
|
||||
for piece in pieces {
|
||||
if !want.contains(piece) {
|
||||
want.add(piece);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let st = s.doc().unwrap();
|
||||
for c in compounds {
|
||||
if st.doc.node(c).is_none() {
|
||||
want.remove(c);
|
||||
}
|
||||
}
|
||||
want.prune(&st.doc);
|
||||
assert_eq!(st.selection, want);
|
||||
st.selection.clone()
|
||||
}
|
||||
|
||||
/// Two lines across split by a rectangle, one of them selected; a selected line nothing crosses
|
||||
/// and a selected compound path of two such lines, which the rectangle removes whole; and a
|
||||
/// selected line elsewhere with an anchor and a segment direct-selected. Returns (the selected
|
||||
/// line across, the line removed whole, the compound path, the line elsewhere).
|
||||
fn trim_scene(s: &mut Session) -> (NodeId, NodeId, NodeId, NodeId) {
|
||||
let (h, ..) = across_and_uprights(s);
|
||||
line(s, &[(0.0, 120.0), (300.0, 120.0)], false);
|
||||
let alone = line(s, &[(145.0, 200.0), (155.0, 200.0)], false);
|
||||
let c1 = line(s, &[(145.0, 170.0), (155.0, 170.0)], false);
|
||||
let c2 = line(s, &[(145.0, 180.0), (155.0, 180.0)], false);
|
||||
s.execute("select.set", &json!({"ids": [c1.0, c2.0]})).unwrap();
|
||||
let compound = NodeId(s.execute("object.compoundPath.make", &json!({})).unwrap()["id"].as_u64().unwrap());
|
||||
let elsewhere = line(s, &[(0.0, 250.0), (10.0, 250.0), (20.0, 250.0)], false);
|
||||
s.execute("select.set", &json!({"ids": [elsewhere.0, h.0, alone.0, compound.0]})).unwrap();
|
||||
s.edit("direct", |_, sel| {
|
||||
sel.anchors.insert(elsewhere, [(0, 1)].into());
|
||||
sel.anchors.insert(h, [(0, 0)].into());
|
||||
sel.segments.insert(elsewhere, [(0, 0)].into());
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
(h, alone, compound, elsewhere)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_selection_after_a_trim_is_the_one_changing_it_one_id_at_a_time_gives() {
|
||||
// A removed key object stops being the key.
|
||||
let mut s = session();
|
||||
let (h, alone, compound, elsewhere) = trim_scene(&mut s);
|
||||
s.edit("key", |_, sel| {
|
||||
sel.key = Some(alone);
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
let sel = same_selection_as_one_id_at_a_time(&mut s, json!({"rect": [140, 90, 20, 120]}));
|
||||
assert_eq!(sel.key, None);
|
||||
assert!(!sel.contains(alone) && !sel.contains(compound));
|
||||
assert_eq!(&sel.objects[..2], [elsewhere, h]);
|
||||
assert_eq!(sel.objects.len(), 3, "{:?}", sel.objects);
|
||||
assert!(sel.anchors.contains_key(&elsewhere) && sel.segments.contains_key(&elsewhere) && !sel.anchors.contains_key(&h));
|
||||
// A key object that keeps its first piece stays the key.
|
||||
let mut s = session();
|
||||
let (h, alone, compound, _) = trim_scene(&mut s);
|
||||
s.edit("key", |_, sel| {
|
||||
sel.key = Some(h);
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
let sel = same_selection_as_one_id_at_a_time(&mut s, json!({"rect": [140, 90, 20, 120]}));
|
||||
assert_eq!(sel.key, Some(h));
|
||||
assert!(!sel.contains(alone) && !sel.contains(compound));
|
||||
// Trimming only paths that are not selected leaves a targeted object targeted.
|
||||
let mut s = session();
|
||||
let (h, _, _, elsewhere) = trim_scene(&mut s);
|
||||
s.execute("select.set", &json!({"ids": [elsewhere.0]})).unwrap();
|
||||
s.edit("target", |_, sel| {
|
||||
sel.target = Some(elsewhere);
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
let sel = same_selection_as_one_id_at_a_time(&mut s, json!({"rect": [140, 90, 20, 40]}));
|
||||
assert_eq!((sel.objects.as_slice(), sel.target), ([elsewhere].as_slice(), Some(elsewhere)));
|
||||
assert!(exists(&s, h));
|
||||
// A selected path that gains a piece changes the object selection, which lets go of the target.
|
||||
let mut s = session();
|
||||
let (h, _, _, elsewhere) = trim_scene(&mut s);
|
||||
s.execute("select.set", &json!({"ids": [elsewhere.0, h.0]})).unwrap();
|
||||
s.edit("target", |_, sel| {
|
||||
sel.target = Some(elsewhere);
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
let sel = same_selection_as_one_id_at_a_time(&mut s, json!({"rect": [140, 90, 20, 40]}));
|
||||
assert_eq!((sel.objects.len(), sel.target), (3, None));
|
||||
// So does a selected path that is removed whole.
|
||||
let mut s = session();
|
||||
let (_, alone, _, elsewhere) = trim_scene(&mut s);
|
||||
s.execute("select.set", &json!({"ids": [elsewhere.0, alone.0]})).unwrap();
|
||||
s.edit("target", |_, sel| {
|
||||
sel.target = Some(elsewhere);
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
let sel = same_selection_as_one_id_at_a_time(&mut s, json!({"rect": [140, 190, 20, 20]}));
|
||||
assert_eq!((sel.objects.as_slice(), sel.target), ([elsewhere].as_slice(), None));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn many_paths_far_from_the_trimmed_one_cost_no_crossing_search() {
|
||||
let mut s = session();
|
||||
@@ -648,3 +782,45 @@ fn bad_params_are_refused_and_change_nothing() {
|
||||
assert_eq!(steps(&s), n);
|
||||
assert!(*s.doc().unwrap().doc == *before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_line_ending_on_a_curve_that_was_cut_still_divides_it_there() {
|
||||
// An open egg-shaped curve, lines across it whose stubs on the left are trimmed away, so each
|
||||
// line ends on the curve, and the curve's bottom trimmed off below the last line, which cuts
|
||||
// its segments there. A click on the curve between the last two lines removes only that
|
||||
// stretch: the lines' ends on it still divide it, however the curve was cut. Twenty placements,
|
||||
// as how near a cut end lies to the curve depends on the coordinates.
|
||||
for shift in 0..20 {
|
||||
let dx = shift as f64 * 7.31;
|
||||
let mut s = session();
|
||||
let egg = json!({"anchors": [
|
||||
{"x": 160.0 + dx, "y": 40.0, "out": [110.0 + dx, 80.0]},
|
||||
{"x": 92.3 + dx, "y": 190.7, "in": [88.0 + dx, 140.0], "out": [97.0 + dx, 240.0]},
|
||||
{"x": 170.0 + dx, "y": 268.0, "in": [130.0 + dx, 265.0], "out": [210.0 + dx, 271.0]},
|
||||
{"x": 236.4 + dx, "y": 170.2, "in": [238.0 + dx, 230.0], "out": [233.0 + dx, 110.0]},
|
||||
{"x": 150.0 + dx, "y": 20.0, "in": [200.0 + dx, 40.0]}
|
||||
], "closed": false});
|
||||
let egg = NodeId(s.execute("path.create", &egg).unwrap()["id"].as_u64().unwrap());
|
||||
s.execute("select.none", &json!({})).unwrap();
|
||||
let ys: Vec<f64> = (0..8).map(|k| 70.0 + k as f64 * 23.17 + shift as f64 * 0.37).collect();
|
||||
let lines: Vec<NodeId> = ys.iter().map(|y| line(&mut s, &[(40.0 + dx, *y), (300.0 + dx, *y)], false)).collect();
|
||||
for y in &ys {
|
||||
assert_eq!(s.execute(TRIM, &json!({"at": [50.0 + dx, y], "tolerance": 0.5})).unwrap()["removed"], json!(1));
|
||||
}
|
||||
assert_eq!(s.execute(TRIM, &json!({"at": [170.0 + dx, 268.0], "tolerance": 0.5})).unwrap()["removed"], json!(1));
|
||||
let start = |id: NodeId| path(&s, id).subpaths[0].anchors[0].p;
|
||||
let ends: Vec<Point> = lines.iter().map(|id| start(*id)).collect();
|
||||
// Off every path but the lines: the curve's pieces.
|
||||
let off_curve = |s: &Session, p: Point| {
|
||||
stack(s).into_iter().filter(|id| !lines.contains(id)).filter_map(|id| path(s, id).nearest(p)).map(|n| n.4).fold(f64::INFINITY, f64::min)
|
||||
};
|
||||
let (a, b) = (ends[6], ends[7]);
|
||||
let click = path(&s, egg).nearest(a.midpoint(b)).unwrap().3;
|
||||
assert!(off_curve(&s, a) < 1e-3 && off_curve(&s, click) < 1e-3);
|
||||
assert_eq!(s.execute(TRIM, &json!({"at": [click.x, click.y], "tolerance": 0.5})).unwrap()["removed"], json!(1));
|
||||
assert!(off_curve(&s, click) > 0.5, "{shift}: the stretch clicked is left");
|
||||
for (k, e) in ends.iter().enumerate().take(7) {
|
||||
assert!(off_curve(&s, *e) < 1e-3, "{shift}: the curve no longer reaches line {k}'s end");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,8 +10,8 @@ use vectorcraft_doc::{ExportAsset, NodeId};
|
||||
|
||||
use super::edit::{refuse_symbol_part, roots_of, selected_roots};
|
||||
use super::fileio::{
|
||||
DEFAULT_FORMAT_3D, FORMATS_3D, SCREEN_SETTINGS_KEYS, check_screen_settings, create_dir, export_crop, export_screens, mesh_file_names, mesh_files,
|
||||
safe_file_name, store_screen_settings, with_screen_export_preset, write_file,
|
||||
DEFAULT_FORMAT_3D, FORMATS_3D, SCREEN_SETTINGS_KEYS, TEXTURE_SIZE, TEXTURE_SIZES, check_screen_settings, create_dir, export_crop, export_screens,
|
||||
image_maps, mesh_file_names, mesh_files, safe_file_name, store_screen_settings, textures, with_screen_export_preset, write_file,
|
||||
};
|
||||
use super::{CommandSpec, EngineError, Result, Session, bad, bool_or, checked_ids_param, cmd, has_doc, ok, str_param, switch_or, text_param};
|
||||
|
||||
@@ -80,7 +80,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Export 3D Assets",
|
||||
[],
|
||||
None,
|
||||
"{assets?: [asset id…] (default every 3D asset), folder?, zip?} each 3D asset's object as a mesh file in its format (assets.set3DFormat), named after the asset: USDA or USDZ, glTF 2.0 (one .gltf, its buffer embedded) or OBJ with its .mtl (whitespace and # in an OBJ's name become _). Every solid of the object (the fill's, each stroke's, a group's members') is a mesh with a material in the color it is painted; faces turned away from the viewer are included, at the object's 3D rotation, y up, about the point it turns about, in points (glTF: meters). Files that would share a name get -2, -3…; an object with a hole that crosses its face's outline or another hole, or with more than 2,000,000 triangles, is refused → {files: [path…]} (no folder: {files: [{name, dataBase64}]}, or with zip one zip as {name, dataBase64, files})",
|
||||
"{assets?: [asset id…] (default every 3D asset), folder?, zip?, textureSize?: 128…4096 (default 1024: the pixels along the longer side of each face's texture)} each 3D asset's object as a mesh file in its format (assets.set3DFormat), named after the asset: USDA or USDZ, glTF 2.0 (one .gltf, its buffer embedded) or OBJ with its .mtl (whitespace and # in an OBJ's name become _). Every solid of the object (the fill's, each stroke's, a group's members') is a mesh with a material in the color it is painted; faces turned away from the viewer are included, at the object's 3D rotation, y up, about the point it turns about, in points (glTF: meters). The graphics mapped onto a plane or onto Extrude & Bevel's front or back cap (threeD.mapGraphic) are a PNG texture of that face: its color with the graphics drawn over it, flat and unlit, on a mesh of the face's own with texture coordinates; glTF embeds it, USDZ stores it after the layer, and OBJ and USDA write it beside them as <name>-texture-1.png… (whitespace, # and @ become _); a face that is not opaque keeps its opacity in the texture's alpha, and an OBJ also gets <name>-texture-1-opacity.png…, the alpha as gray levels for its map_d. Graphics on Revolve's side are not exported. Files that would share a name get -2, -3…; an object with a hole that crosses its face's outline or another hole, or with more than 2,000,000 triangles, or textures of more than 67,108,864 pixels in one export, is refused → {files: [path…]} (no folder: {files: [{name, dataBase64}]}, or with zip one zip as {name, dataBase64, files})",
|
||||
has_doc,
|
||||
export_3d
|
||||
),
|
||||
@@ -299,6 +299,8 @@ fn export_3d(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
let folder = text_param(p, "folder", C)?.filter(|f| !f.is_empty());
|
||||
let zip = switch_or(p, "zip", false, C)?;
|
||||
let size = texture_size_param(p, C)?;
|
||||
let mut pixels = 0u64;
|
||||
// Every file's name, compared without case: a later file that would take one gets -2, -3…
|
||||
let mut taken: HashSet<String> = HashSet::new();
|
||||
let mut files: Vec<(String, Vec<u8>)> = vec![];
|
||||
@@ -311,18 +313,20 @@ fn export_3d(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let what = &a.name;
|
||||
let parts =
|
||||
vectorcraft_render::effects::three_d_meshes_of_in(Some(d), nodes).map_err(|e| bad(C, format!("{what} can't be exported in 3D: {e}")))?;
|
||||
let pictures = textures(d, &parts, size, &mut pixels).map_err(|e| bad(C, format!("{what} can't be exported in 3D: {e}")))?;
|
||||
let images = image_maps(&pictures);
|
||||
let base = Some(safe_file_name(&a.name)).filter(|b| !b.is_empty()).unwrap_or_else(|| "Asset".into());
|
||||
let mut stem = base.clone();
|
||||
let mut k = 1;
|
||||
loop {
|
||||
let names = mesh_file_names(&stem, format).map_err(|e| bad(C, e))?;
|
||||
let names = mesh_file_names(&stem, format, &images).map_err(|e| bad(C, e))?;
|
||||
if names.iter().all(|n| !taken.contains(&n.to_lowercase())) {
|
||||
break;
|
||||
}
|
||||
k += 1;
|
||||
stem = format!("{base}-{k}");
|
||||
}
|
||||
let made = mesh_files(&stem, format, &parts).map_err(|e| bad(C, e))?;
|
||||
let made = mesh_files(&stem, format, &parts, &pictures).map_err(|e| bad(C, e))?;
|
||||
taken.extend(made.iter().map(|(n, _)| n.to_lowercase()));
|
||||
files.extend(made);
|
||||
}
|
||||
@@ -360,6 +364,21 @@ fn export_3d(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Param `textureSize` of command `cmd`: the pixels along the longer side of each face's texture,
|
||||
/// [`TEXTURE_SIZE`] when it is not given.
|
||||
fn texture_size_param(p: &Value, cmd: &str) -> Result<u32> {
|
||||
let key = "textureSize";
|
||||
let (lo, hi) = TEXTURE_SIZES;
|
||||
match p.get(key) {
|
||||
None | Some(Value::Null) => Ok(TEXTURE_SIZE),
|
||||
Some(v) => v
|
||||
.as_u64()
|
||||
.and_then(|n| u32::try_from(n).ok())
|
||||
.filter(|n| (lo..=hi).contains(n))
|
||||
.ok_or_else(|| bad(cmd, format!("`{key}` must be a whole number of pixels from {lo} to {hi}"))),
|
||||
}
|
||||
}
|
||||
|
||||
/// The asset ids of param `key`.
|
||||
fn asset_ids(p: &Value, key: &str, cmd: &str) -> Result<Vec<u64>> {
|
||||
let ids = p.get(key).and_then(Value::as_array).ok_or_else(|| bad(cmd, format!("`{key}` must be an array of asset ids (see assets.list)")))?;
|
||||
|
||||
@@ -5,15 +5,16 @@ use super::{
|
||||
|
||||
// ---------- brushes ----------
|
||||
|
||||
/// Brushable nodes (paths and compound paths) under `ids`.
|
||||
/// Brushable nodes (paths and compound paths) under `ids`, in walk order, each listed once where it is first reached.
|
||||
pub(crate) fn brush_targets(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
|
||||
let mut out = vec![];
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
for id in ids {
|
||||
let Some(n) = d.node(*id) else { continue };
|
||||
n.walk(&mut |c| {
|
||||
let own = matches!(c.kind, NodeKind::Path { guide: false, clipping: false, .. } | NodeKind::Compound { .. });
|
||||
let in_compound = d.parent_of(c.id).and_then(|p| d.node(p)).is_some_and(|p| matches!(p.kind, NodeKind::Compound { .. }));
|
||||
if own && !in_compound && !out.contains(&c.id) {
|
||||
if own && !in_compound && seen.insert(c.id) {
|
||||
out.push(c.id);
|
||||
}
|
||||
});
|
||||
@@ -748,3 +749,92 @@ pub(super) fn brush_freehand(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let checked = crate::schemas::check(spec, p, s.replaying())?;
|
||||
crate::cmd::draw2::freehand_brushed(s, checked.as_ref().unwrap_or(p), name.as_deref())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use vectorcraft_doc::Appearance;
|
||||
use vectorcraft_geom::PathData;
|
||||
|
||||
/// The collector with a linear search of its output, kept to compare results with.
|
||||
fn listed_targets(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
|
||||
let mut out = vec![];
|
||||
for id in ids {
|
||||
let Some(n) = d.node(*id) else { continue };
|
||||
n.walk(&mut |c| {
|
||||
let own = matches!(c.kind, NodeKind::Path { guide: false, clipping: false, .. } | NodeKind::Compound { .. });
|
||||
let in_compound = d.parent_of(c.id).and_then(|p| d.node(p)).is_some_and(|p| matches!(p.kind, NodeKind::Compound { .. }));
|
||||
if own && !in_compound && !out.contains(&c.id) {
|
||||
out.push(c.id);
|
||||
}
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn path(d: &mut Document) -> Node {
|
||||
Node::path(d.alloc_id(), PathData::default(), Appearance::default())
|
||||
}
|
||||
|
||||
fn compound(d: &mut Document, children: Vec<Node>) -> Node {
|
||||
Node::new(d.alloc_id(), NodeKind::Compound { children: children.into_iter().map(Arc::new).collect(), rule: Default::default() })
|
||||
}
|
||||
|
||||
fn add(d: &mut Document, node: Node) -> NodeId {
|
||||
let layer = d.layers.first().map(|l| l.id);
|
||||
d.insert(layer, usize::MAX, node).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn brush_targets_list_each_target_once_in_first_reached_order() {
|
||||
let mut d = Document::new(400.0, 300.0);
|
||||
let a = path(&mut d);
|
||||
let a = add(&mut d, a);
|
||||
let mut guide = path(&mut d);
|
||||
if let NodeKind::Path { guide: g, .. } = &mut guide.kind {
|
||||
*g = true;
|
||||
}
|
||||
let guide = add(&mut d, guide);
|
||||
let mut clip = path(&mut d);
|
||||
if let NodeKind::Path { clipping, .. } = &mut clip.kind {
|
||||
*clipping = true;
|
||||
}
|
||||
let clip = add(&mut d, clip);
|
||||
// A group holding a path and a compound path of two members.
|
||||
let p1 = path(&mut d);
|
||||
let p1_id = p1.id;
|
||||
let (m1, m2) = (path(&mut d), path(&mut d));
|
||||
let m1_id = m1.id;
|
||||
let cp1 = compound(&mut d, vec![m1, m2]);
|
||||
let cp1_id = cp1.id;
|
||||
let group = Node::group(d.alloc_id(), vec![Arc::new(p1), Arc::new(cp1)]);
|
||||
let group = add(&mut d, group);
|
||||
// A compound path holding a compound path.
|
||||
let m3 = path(&mut d);
|
||||
let cp3 = compound(&mut d, vec![m3]);
|
||||
let cp3_id = cp3.id;
|
||||
let cp2 = compound(&mut d, vec![cp3]);
|
||||
let cp2 = add(&mut d, cp2);
|
||||
|
||||
let ids = [cp1_id, a, group, p1_id, a, guide, clip, m1_id, cp2, cp3_id, NodeId(u64::MAX)];
|
||||
let got = brush_targets(&d, &ids);
|
||||
assert_eq!(got, [cp1_id, a, p1_id, cp2], "repeats keep their first place; guides, clipping paths and compound members are left out");
|
||||
assert_eq!(got, listed_targets(&d, &ids));
|
||||
assert!(brush_targets(&d, &[]).is_empty());
|
||||
|
||||
// Many paths in groups, each group listed with some of its members.
|
||||
let mut ids = vec![];
|
||||
for _ in 0..50 {
|
||||
let members: Vec<Node> = (0..20).map(|_| path(&mut d)).collect();
|
||||
let member_ids: Vec<NodeId> = members.iter().map(|m| m.id).collect();
|
||||
let g = Node::group(d.alloc_id(), members.into_iter().map(Arc::new).collect());
|
||||
let g = add(&mut d, g);
|
||||
ids.push(member_ids[7]);
|
||||
ids.push(g);
|
||||
ids.push(member_ids[3]);
|
||||
}
|
||||
let got = brush_targets(&d, &ids);
|
||||
assert_eq!(got.len(), 50 * 20);
|
||||
assert_eq!(got, listed_targets(&d, &ids));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -38,6 +38,7 @@ mod shape_builder;
|
||||
mod trace;
|
||||
|
||||
pub use live_paint::live_paint_gaps;
|
||||
pub(crate) use live_paint::{isolated_live_paint, merge_drawn_in_isolation};
|
||||
use live_paint::{lp_expand, lp_fill, lp_gap_options, lp_info, lp_make, lp_merge, lp_release, lp_stroke_edge};
|
||||
use shape_builder::{sb_merge, sb_regions};
|
||||
pub(crate) use trace::TracePresetChanges;
|
||||
@@ -144,7 +145,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Make",
|
||||
["Object", "Image Trace"],
|
||||
None,
|
||||
"{id?: image or Image Trace group (default: selection), preset?: name (imageTrace.presets), savedPreset?: {settings} (a saved preset's settings, which the journal records so a replay traces with them after the preset is changed, renamed or deleted; used in place of the saved preset `preset` names), enhanced?: false (the preset's enhanced version: with Auto Grouping, and with Shapes in all but High Fidelity Photo; Flat Logo has none and is traced as it is), params?: {mode: \"blackAndWhite\"|\"grayscale\"|\"color\"|\"logo\", threshold: 0-255, palette: \"limited\"|\"fullTone\"|\"automatic\"|\"documentLibrary\" (color mode; limited: the `colors` best colours, fullTone: as many as the tones need, more with colorDetail, automatic: flat art with its own colours, else fullTone, documentLibrary: at most `colors` of the library's colours, as they are), colors: 2-256, colorDetail: 0-100 (fullTone, automatic), library: \"document\" (the document's swatches) or a swatch library id or name (swatch.library.list; documentLibrary), colorGroup?: name (color mode, documentLibrary with library \"document\": the colors of that document color group instead of every swatch; \"\" is every swatch), paths: 0-100, corners: 0-100, noise: px (an area smaller than this joins the color it shares the longest border with; when that color is far from its own and the area is 2 px or more, or a single pixel whose longest border is not tied between colors, it joins the neighboring color nearest its pixels among those sharing at least a tenth of that border), method: \"abutting\"|\"overlapping\" (abutting with fills, not mode logo: a \"Seam Fills\" clip group under the paths holds strokes along the edges two filled paths share, 1.5 image pixels wide (VectorCraft's own width), in the color of the lower path (on an image stretched more one way than another, each stroke's outline in image pixels as a filled path), clipped to the image's box within the traced paths' box; paths that became live shapes get none; the paths are not changed), ignoreWhite (leave out white areas), ignoreColor?: \"#rrggbb\" (with ignoreWhite: the colour left out instead of white), ignoreBackground: false (with ignoreWhite: only the areas of the ignored color that reach the image's edge are left out), keepColors?: [\"#rrggbb\"…] (not mode logo: only the palette colors within about 30 levels of a listed color are traced; empty: every color), snapCurvesToLines, shapes: false (filled outlines that are a circle, an ellipse, a rectangle or a regular polygon come out as that live shape), autoGrouping: false (each path that has others inside it is grouped with them), gradients: false (grayscale and color: an area whose colour changes evenly along one direction is one path with a linear gradient fill), fills: true, strokes: false (Create: lines up to strokeWidth wide become stroked centre lines; without fills, wider areas become stroked outlines), strokeWidth: px (10), logoColors?: [\"#rrggbb\"…] (mode logo: flat-colour logos only; colours found automatically or named here, at most ten; white is its own color, and a named color with every channel 245 or more is taken as that white, except with logoColors named, logoWhite false and no ignoreWhite; noise = areas under noise/10 px ignored; edges to a fraction of a pixel, sharp corners restored, lines and circles snapped; enclosed transparent areas are painted white while white is its own color, and stay holes with ignoreWhite or without a white of its own; fills/strokes are ignored; gradients and photos are refused, judged by the image's own colors also when logoColors are named), logoWhite: true (mode logo with logoColors named; false traces the named colors only: white areas take the nearest of them, a named white is kept and enclosed transparent areas stay holes; with ignoreWhite, white areas are left out either way)}, view?: as imageTrace.setView (default: the traced object's own, else tracingResult), ids?: [id…] (instead of id)} → {id, paths, anchors, colors, warnings: [text…] (the image is over 1500 px on a side, so it traces more slowly; or it was traced scaled down; Flat Logo names only the size it traced a larger image at; or a keepColors color matches none the trace found, or nothing was traced)}",
|
||||
"{id?: image or Image Trace group (default: selection), preset?: name (imageTrace.presets), savedPreset?: {settings} (a saved preset's settings, which the journal records so a replay traces with them after the preset is changed, renamed or deleted; used in place of the saved preset `preset` names), enhanced?: false (the preset's enhanced version: with Auto Grouping, and with Shapes in all but High Fidelity Photo; Flat Logo has none and is traced as it is), params?: {mode: \"blackAndWhite\"|\"grayscale\"|\"color\"|\"logo\", threshold: 0-255, palette: \"limited\"|\"fullTone\"|\"automatic\"|\"documentLibrary\" (color mode; limited: the `colors` best colours, fullTone: as many as the tones need, more with colorDetail, split into at least colorDetail colors where the image has that many before colors that look alike merge (less than 5 apart in Oklab × 100 and thoroughly mixed, or less than 1.5 and mixed in patches), automatic: flat art with its own colours, else as many as the tones need without fullTone's least count, merging close RGB colors, documentLibrary: at most `colors` of the library's colours, as they are), colors: 2-256, colorDetail: 0-100 (fullTone, automatic), library: \"document\" (the document's swatches) or a swatch library id or name (swatch.library.list; documentLibrary), colorGroup?: name (color mode, documentLibrary with library \"document\": the colors of that document color group instead of every swatch; \"\" is every swatch), paths: 0-100, corners: 0-100, noise: px (an area smaller than this joins the color it shares the longest border with; when that color is far from its own and the area is 2 px or more, or a single pixel whose longest border is not tied between colors, it joins the neighboring color nearest its pixels among those sharing at least a tenth of that border), method: \"abutting\"|\"overlapping\" (abutting with fills, not mode logo: a \"Seam Fills\" clip group under the paths holds strokes along the edges two filled paths share, 1.5 image pixels wide (VectorCraft's own width), in the color of the lower path (on an image stretched more one way than another, each stroke's outline in image pixels as a filled path), clipped to the image's box within the traced paths' box; paths that became live shapes get none; the paths are not changed), ignoreWhite (leave out white areas), ignoreColor?: \"#rrggbb\" (with ignoreWhite: the colour left out instead of white), ignoreBackground: false (with ignoreWhite: only the areas of the ignored color that reach the image's edge are left out), keepColors?: [\"#rrggbb\"…] (not mode logo: only the palette colors within about 30 levels of a listed color are traced; empty: every color), snapCurvesToLines, shapes: false (filled outlines that are a circle, an ellipse, a rectangle or a regular polygon come out as that live shape), autoGrouping: false (each path that has others inside it is grouped with them), gradients: false (grayscale and color: an area whose colour changes evenly along one direction is one path with a linear gradient fill), fills: true, strokes: false (Create: lines up to strokeWidth wide become stroked centre lines; without fills, wider areas become stroked outlines), strokeWidth: px (10), logoColors?: [\"#rrggbb\"…] (mode logo: flat-colour logos only; colours found automatically or named here, at most ten; white is its own color, and a named color with every channel 245 or more is taken as that white, except with logoColors named, logoWhite false and no ignoreWhite; noise = areas under noise/10 px ignored; edges to a fraction of a pixel, sharp corners restored, lines and circles snapped; enclosed transparent areas are painted white while white is its own color, and stay holes with ignoreWhite or without a white of its own; fills/strokes are ignored; gradients and photos are refused, judged by the image's own colors also when logoColors are named), logoWhite: true (mode logo with logoColors named; false traces the named colors only: white areas take the nearest of them, a named white is kept and enclosed transparent areas stay holes; with ignoreWhite, white areas are left out either way)}, view?: as imageTrace.setView (default: the traced object's own, else tracingResult), ids?: [id…] (instead of id)} → {id, paths, anchors, colors, warnings: [text…] (the image is over 1500 px on a side, so it traces more slowly; or it was traced scaled down; Flat Logo names only the size it traced a larger image at; or a keepColors color matches none the trace found, or nothing was traced)}",
|
||||
has_selection_or_ids,
|
||||
|s, p| trace_make(s, p, false)
|
||||
),
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
use super::{
|
||||
Appearance, AppearanceItem, Arc, Beside, Document, EDGE_NAME, EngineError, FACE_NAME, GapOptions, GapSize, LIVE_PAINT_NAME, Node, NodeId,
|
||||
PathData, Point, Rect, Result, SOURCES_NAME, Selection, Session, SubPath, Value, b, bad, build_children, edge_near, face_at, finite,
|
||||
fit_to_old_edge, ids_json, is_live_paint, json, number_or, object_param, paint_from, po, point_param, repaint_from, replace_roots, root_ids,
|
||||
source_nodes, source_shapes, switch_or,
|
||||
PathData, Point, Rect, Result, Selection, Session, SubPath, Value, b, bad, build_children, edge_near, face_at, finite, fit_to_old_edge, ids_json,
|
||||
is_live_paint, json, number_or, object_param, paint_from, po, point_param, repaint_from, replace_roots, root_ids, source_nodes, source_shapes,
|
||||
switch_or,
|
||||
};
|
||||
|
||||
/// `options` as stored on a Live Paint group: none for the defaults.
|
||||
@@ -53,6 +53,27 @@ fn make_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result<
|
||||
Ok((gid, nf, ne))
|
||||
}
|
||||
|
||||
/// The children of Live Paint group `g` besides its sources group ([`b::sources`]) and its faces and
|
||||
/// edges (paths named [`FACE_NAME`] or [`EDGE_NAME`]), back to front: objects drawn in it in
|
||||
/// isolation mode. A group or other object named like a part is one of them.
|
||||
fn others_in(g: &Node) -> impl Iterator<Item = &Arc<Node>> {
|
||||
let src = b::sources(g).map(|s| s.id);
|
||||
g.children()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter(move |c| Some(c.id) != src && !(c.path_data().is_some() && matches!(c.name.as_deref(), Some(FACE_NAME | EDGE_NAME))))
|
||||
}
|
||||
|
||||
/// Make `parts` (a sources group, faces and edges made again) the children of Live Paint group `g`,
|
||||
/// with its other children ([`others_in`]) that are not among `gone` kept in front of them, in their
|
||||
/// order.
|
||||
fn set_parts(g: &mut Node, mut parts: Vec<Arc<Node>>, gone: &[NodeId]) {
|
||||
parts.extend(others_in(g).filter(|c| !gone.contains(&c.id)).cloned());
|
||||
if let Some(ch) = g.children_mut() {
|
||||
*ch = parts;
|
||||
}
|
||||
}
|
||||
|
||||
/// Select `ids` alone, without an undo step, when they are not selected that way already.
|
||||
fn select_only(s: &mut Session, ids: &[NodeId]) -> Result<()> {
|
||||
let st = s.doc()?;
|
||||
@@ -134,9 +155,15 @@ fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result
|
||||
b::faces(&old).iter().filter(|f| draws(f)).filter_map(|f| Some((po::interior_point(f.path_data()?)?, Carried::of(f)))).collect();
|
||||
let old_parts = old.clone();
|
||||
let mut sources = source_nodes(&old);
|
||||
// The objects drawn in the other Live Paint groups besides their parts stay in the merged group.
|
||||
let mut others = vec![];
|
||||
for r in roots {
|
||||
if *r != target {
|
||||
sources.extend(source_nodes(d.node(*r).ok_or(EngineError::NoNode(*r))?));
|
||||
let n = d.node(*r).ok_or(EngineError::NoNode(*r))?;
|
||||
sources.extend(source_nodes(n));
|
||||
if is_live_paint(n) {
|
||||
others.extend(others_in(n).cloned());
|
||||
}
|
||||
}
|
||||
}
|
||||
// Merge applies the Gap Options' merge rules to the groups' options, bottom-most first.
|
||||
@@ -146,8 +173,9 @@ fn merge_live(d: &mut Document, sel: &mut Selection, roots: &[NodeId]) -> Result
|
||||
// The group keeps its name, lock, visibility, transparency, appearance, opacity mask, graphic
|
||||
// style link and the rest; its children are made again and its Gap Options set to the merged ones.
|
||||
let mut g = old;
|
||||
set_parts(&mut g, children, roots);
|
||||
if let Some(ch) = g.children_mut() {
|
||||
*ch = children;
|
||||
ch.extend(others);
|
||||
}
|
||||
g.extras_mut().live_paint_gaps = stored_gap_options(options);
|
||||
for (pt, carried) in keep_faces {
|
||||
@@ -199,6 +227,38 @@ pub(super) fn lp_merge(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(json!({ "id": id.0, "faces": faces, "edges": edges }))
|
||||
}
|
||||
|
||||
/// The Live Paint group whose drawn art is added when isolation mode leaves `isolated`: the innermost
|
||||
/// Live Paint group that is `isolated` or holds it, such as a group drawn in an isolated Live Paint
|
||||
/// group and then isolated itself. None when `isolated` is not in a Live Paint group.
|
||||
pub(crate) fn isolated_live_paint(d: &Document, isolated: NodeId) -> Option<NodeId> {
|
||||
d.ancestry(isolated)?.into_iter().rev().find(|id| d.node(*id).is_some_and(is_live_paint))
|
||||
}
|
||||
|
||||
/// The children of Live Paint group `g` besides its parts ([`others_in`]) that Live Paint takes
|
||||
/// ([`b::live_paint_takes`]) and that are shown and unlocked with everything in them, back to
|
||||
/// front: the paths drawn in it in isolation mode.
|
||||
fn drawn_in(g: &Node) -> Vec<NodeId> {
|
||||
fn open(n: &Node) -> bool {
|
||||
n.visible && !n.locked && n.children().is_none_or(|ch| ch.iter().all(|c| open(c)))
|
||||
}
|
||||
others_in(g).filter(|c| open(c) && b::live_paint_takes(c)).map(|c| c.id).collect()
|
||||
}
|
||||
|
||||
/// Leaving isolation mode in Live Paint group `g` adds the paths drawn in it to the group as
|
||||
/// `livePaint.merge` does, in one "Merge Live Paint" undo step; → whether any were added. Type,
|
||||
/// images, other objects Live Paint does not take, and hidden or locked objects stay where they
|
||||
/// are. With nothing to add, or when `g` is not a Live Paint group, nothing changes and no undo
|
||||
/// step is recorded.
|
||||
pub(crate) fn merge_drawn_in_isolation(s: &mut Session, g: NodeId) -> Result<bool> {
|
||||
let drawn = s.doc()?.doc.node(g).filter(|n| is_live_paint(n)).map(drawn_in).unwrap_or_default();
|
||||
if drawn.is_empty() {
|
||||
return Ok(false);
|
||||
}
|
||||
let roots: Vec<NodeId> = std::iter::once(g).chain(drawn).collect();
|
||||
s.edit("Merge Live Paint", |d, sel| merge_live(d, sel, &roots))?;
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn live_targets(s: &Session, p: &Value) -> Result<Vec<NodeId>> {
|
||||
let d = &s.doc()?.doc;
|
||||
let ids = root_ids(s, p)?;
|
||||
@@ -216,7 +276,8 @@ pub(super) fn lp_release(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let mut released = Beside::replacing(d, &targets);
|
||||
for g in &targets {
|
||||
let n = d.node(*g).cloned().ok_or(EngineError::NoNode(*g))?;
|
||||
let srcs: Vec<Node> = source_nodes(&n).iter().map(|c| (**c).clone()).collect();
|
||||
// The objects drawn in the group besides its parts are released in front of its paths.
|
||||
let srcs: Vec<Node> = source_nodes(&n).iter().chain(others_in(&n)).map(|c| (**c).clone()).collect();
|
||||
out.extend(srcs.iter().map(|c| c.id));
|
||||
released.put(d, *g, srcs)?;
|
||||
}
|
||||
@@ -245,10 +306,12 @@ pub(super) fn lp_expand(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
e.trace = None;
|
||||
e.live_paint_gaps = None;
|
||||
}
|
||||
// Objects drawn in the group ([`others_in`]) stay, whatever they are named.
|
||||
let src = b::sources(n).map(|c| c.id);
|
||||
if let Some(ch) = n.children_mut() {
|
||||
ch.retain(|c| match c.name.as_deref() {
|
||||
Some(SOURCES_NAME) => false,
|
||||
Some(FACE_NAME | EDGE_NAME) => draws(c),
|
||||
_ if Some(c.id) == src => false,
|
||||
Some(FACE_NAME | EDGE_NAME) if c.path_data().is_some() => draws(c),
|
||||
_ => true,
|
||||
});
|
||||
}
|
||||
@@ -354,9 +417,7 @@ pub(super) fn lp_gap_options(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
// The faces change only with what paint stops at, or with new paths.
|
||||
if added > 0 || options.max_gap() != old.gap_options().max_gap() {
|
||||
let (children, _, _) = build_children(d, sources, options.max_gap())?;
|
||||
if let Some(ch) = n.children_mut() {
|
||||
*ch = children;
|
||||
}
|
||||
set_parts(&mut n, children, &[]);
|
||||
repaint_from(&mut n, &old);
|
||||
}
|
||||
n.extras_mut().live_paint_gaps = stored_gap_options(options);
|
||||
|
||||
@@ -209,7 +209,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Load Metafile into Clipboard",
|
||||
[],
|
||||
None,
|
||||
"{dataBase64 (EMF or WMF bytes), center?: [x, y]} replace the clipboard with the picture's objects (paths, clipping groups, images, point type; the images they use), centred on `center` (default: the first artboard) → {count, warnings}; records VectorCraft doesn't read are skipped with one warning; then run edit.paste",
|
||||
"{dataBase64 (EMF or WMF bytes), center?: [x, y]} replace the clipboard with the picture's objects (paths, clipping groups, images, point type; the images they use), centred on `center` (default: the first artboard) → {count, warnings}; records VectorCraft doesn't read are skipped with one warning; a picture cut short by a reader limit, images and pattern brushes that can't be read, clips that can't be applied and raster operations other than a plain copy each add a warning; then run edit.paste",
|
||||
has_doc,
|
||||
import_emf
|
||||
),
|
||||
|
||||
+129
-22
@@ -53,12 +53,29 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Flare",
|
||||
[],
|
||||
None,
|
||||
"{cx, cy, diameter=100, opacity=50 (%), brightness=30 (%), growth=20 (%), fuzziness=50 (%), rays=15, longest=300 (%), rayFuzziness=100 (%), rotation=0 (deg, turns the rays clockwise), x2?, y2? (ring end; else pathLength at direction), pathLength=300, rings=10, largest=50 (%), direction=45 (deg counter-clockwise from 3 o'clock: where the rings run from the centre), seed?, ringSeed? (whole number below 2^53: places the rings along the path anew, keeping their count and sizes)} → {id}",
|
||||
"{cx, cy, diameter=100, opacity=50 (%), brightness=30 (%), growth=20 (%), fuzziness=50 (%), rays=15, longest=300 (%), rayFuzziness=100 (%), rotation=0 (deg, turns the rays clockwise), x2?, y2? (ring end; else pathLength at direction), pathLength=300, rings=10, largest=50 (%), direction=45 (deg counter-clockwise from 3 o'clock: where the rings run from the centre), seed?, ringSeed? (whole number below 2^53: deterministically places every ring along the path, including the first for small seed values, keeping their count and sizes)} → {id}",
|
||||
has_doc,
|
||||
flare
|
||||
),
|
||||
cmd!(
|
||||
"shape.circleThroughPoints",
|
||||
"Circle Through Points",
|
||||
[],
|
||||
None,
|
||||
"{points?: [[x, y], [x, y], [x, y]] (left out: the three selected anchor points, where a path selected whole counts all its anchors and selected segments' ends do not count)} → {id, cx, cy, radius}: a circle with the current paint whose edge passes through the three points, not pixel-aligned even while Align New Objects to Pixel Grid is on; two points that are the same or three on one line are an error, and nothing is drawn",
|
||||
has_doc,
|
||||
circle_through_points
|
||||
),
|
||||
cmd!("shape.line", "Line Segment", [], None, "{x1, y1, x2, y2, fill?: bool (Fill Line: the current fill, else none)} → {id}", has_doc, line),
|
||||
cmd!("shape.spiral", "Spiral", [], None, "{cx, cy, radius, decay=80 (%), segments=10, clockwise?} → {id}", has_doc, spiral),
|
||||
cmd!(
|
||||
"shape.spiral",
|
||||
"Spiral",
|
||||
[],
|
||||
None,
|
||||
"{cx, cy, radius, decay=80 (%), segments=10, clockwise?, rotation?: deg clockwise about (cx, cy)} (0: outer end at (cx + radius, cy)) → {id}",
|
||||
has_doc,
|
||||
spiral
|
||||
),
|
||||
cmd!(
|
||||
"shape.arc",
|
||||
"Arc",
|
||||
@@ -116,13 +133,6 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
]
|
||||
}
|
||||
|
||||
/// Insert a new object at the top of the insertion parent with the current paint and new-art
|
||||
/// template; select it.
|
||||
pub(crate) fn add_art(s: &mut Session, label: &str, kind: NodeKind, name: Option<String>) -> Result<Value> {
|
||||
let look = s.new_art_look(s.paint.fill.clone(), s.paint.stroke.clone(), s.paint.stroke_width);
|
||||
add_look(s, label, kind, look, name)
|
||||
}
|
||||
|
||||
/// Insert a new object looking like `look` (drawing modes apply); select it.
|
||||
pub(crate) fn add_look(s: &mut Session, label: &str, kind: NodeKind, look: NewArt, name: Option<String>) -> Result<Value> {
|
||||
insert_look(s, label, kind, look, name, true)
|
||||
@@ -131,14 +141,22 @@ pub(crate) fn add_look(s: &mut Session, label: &str, kind: NodeKind, look: NewAr
|
||||
/// [`add_look`] that selects the new object only when `select` is set; otherwise the selection
|
||||
/// stays as it was.
|
||||
pub(crate) fn insert_look(s: &mut Session, label: &str, kind: NodeKind, look: NewArt, name: Option<String>, select: bool) -> Result<Value> {
|
||||
insert_look_turned(s, label, kind, look, name, select, 0.0)
|
||||
insert_look_turned(s, label, kind, look, name, select, 0.0, true)
|
||||
}
|
||||
|
||||
/// [`add_art`] for an object made turned by a `rotation` param (degrees, clockwise on the page):
|
||||
/// Insert a new object at the top of the insertion parent with the current paint and new-art
|
||||
/// template, made turned by a `rotation` param (degrees, clockwise on the page), and select it:
|
||||
/// its bounding box turns with it, as after the Rotate tool.
|
||||
fn add_art_turned(s: &mut Session, label: &str, kind: NodeKind, rotation: f64) -> Result<Value> {
|
||||
let look = s.new_art_look(s.paint.fill.clone(), s.paint.stroke.clone(), s.paint.stroke_width);
|
||||
insert_look_turned(s, label, kind, look, None, true, bbox_turn(rotation))
|
||||
insert_look_turned(s, label, kind, look, None, true, bbox_turn(rotation), true)
|
||||
}
|
||||
|
||||
/// [`add_art`] for an object whose geometry must stay where it was computed: it is not
|
||||
/// pixel-aligned, even while the document's Align New Objects to Pixel Grid is on.
|
||||
fn add_art_unaligned(s: &mut Session, label: &str, kind: NodeKind) -> Result<Value> {
|
||||
let look = s.new_art_look(s.paint.fill.clone(), s.paint.stroke.clone(), s.paint.stroke_width);
|
||||
insert_look_turned(s, label, kind, look, None, true, 0.0, false)
|
||||
}
|
||||
|
||||
/// The bounding-box angle (counter-clockwise, as `Node::bbox_angle` and the Rotate tool keep it)
|
||||
@@ -162,8 +180,10 @@ fn constrained_turn(s: &Session, rotation: f64) -> f64 {
|
||||
}
|
||||
}
|
||||
|
||||
/// [`insert_look`] with the new object's bounding box turned to `bbox_angle`. A new path or
|
||||
/// compound path is pixel-aligned while the document's Align New Objects to Pixel Grid is on.
|
||||
/// [`insert_look`] with the new object's bounding box turned to `bbox_angle`. With `align`, a new
|
||||
/// path or compound path is pixel-aligned while the document's Align New Objects to Pixel Grid is
|
||||
/// on.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn insert_look_turned(
|
||||
s: &mut Session,
|
||||
label: &str,
|
||||
@@ -172,6 +192,7 @@ fn insert_look_turned(
|
||||
name: Option<String>,
|
||||
select: bool,
|
||||
bbox_angle: f64,
|
||||
align: bool,
|
||||
) -> Result<Value> {
|
||||
let parent = s.doc()?.target_parent()?;
|
||||
let mode = s.draw_mode;
|
||||
@@ -181,7 +202,9 @@ fn insert_look_turned(
|
||||
let id = d.alloc_id();
|
||||
let mut n = Node::new(id, kind);
|
||||
look.apply(d, &mut n);
|
||||
super::object::align_new_object(d, &mut n);
|
||||
if align {
|
||||
super::object::align_new_object(d, &mut n);
|
||||
}
|
||||
n.name = name;
|
||||
n.bbox_angle = bbox_angle;
|
||||
let mut into = None;
|
||||
@@ -300,7 +323,7 @@ fn path_kind(path: PathData, live: Option<LiveShape>) -> NodeKind {
|
||||
/// a box (rectangle, ellipse, grid) runs along the turned axes from `pivot`, the point the dialog
|
||||
/// placed at the click (its top-left corner `x`, `y`, or a grid's reference point), which stays
|
||||
/// put; an arc sized by its lengths turns about its reference point `x`, `y`, which the dialog
|
||||
/// placed at the click; a polygon or star turns its base orientation about its centre. The params as they are at
|
||||
/// placed at the click; a polygon, star or spiral turns its base orientation about its centre. The params as they are at
|
||||
/// 0° or a whole turn, for other commands and when they already carry a `rotation`.
|
||||
pub fn constrain_click(s: &Session, cmd: &str, mut params: Value, pivot: Point) -> Value {
|
||||
let base = s.prefs.constrain_angle;
|
||||
@@ -316,7 +339,7 @@ pub fn constrain_click(s: &Session, cmd: &str, mut params: Value, pivot: Point)
|
||||
o.insert("y".into(), json!(c.y - h / 2.0));
|
||||
o.insert("rotation".into(), json!(rotation));
|
||||
}
|
||||
"shape.polygon" | "shape.star" => {
|
||||
"shape.polygon" | "shape.star" | "shape.spiral" => {
|
||||
o.insert("rotation".into(), json!(rotation));
|
||||
}
|
||||
"shape.arc" if o.contains_key("lengthX") || o.contains_key("lengthY") => {
|
||||
@@ -390,6 +413,71 @@ fn ellipse(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
add_art_turned(s, "Ellipse", path_kind(live.to_path(), Some(live)), rotation)
|
||||
}
|
||||
|
||||
/// A live ellipse whose edge passes through three points: `points`, or the three selected anchor
|
||||
/// points ([`selected_anchor_points`]). One undo step, named as an Ellipse tool drag is.
|
||||
fn circle_through_points(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
const C: &str = "shape.circleThroughPoints";
|
||||
let points = match p.get("points").filter(|v| !v.is_null()) {
|
||||
Some(v) => three_points(v).ok_or_else(|| bad(C, "`points` must be three [x, y] pairs of numbers"))?,
|
||||
None => selected_anchor_points(s)?.ok_or_else(|| bad(C, "direct-select three anchor points, or give `points`"))?,
|
||||
};
|
||||
let [a, b, c] = points;
|
||||
let (center, radius) = shapes::circle_through(a, b, c)
|
||||
.ok_or_else(|| bad(C, "no circle passes through these points: two are the same or all three lie on one line"))?;
|
||||
let r = Rect::new(center.x - radius, center.y - radius, center.x + radius, center.y + radius);
|
||||
let live = LiveShape::Ellipse { w: r.width(), h: r.height(), pie: (0.0, 360.0), xf: Affine::translate(r.origin().to_vec2()) };
|
||||
// Not pixel-aligned: the circle stays through the points.
|
||||
let mut out = add_art_unaligned(s, "Ellipse", path_kind(live.to_path(), Some(live)))?;
|
||||
out["cx"] = json!(center.x);
|
||||
out["cy"] = json!(center.y);
|
||||
out["radius"] = json!(radius);
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The three points `[[x, y], [x, y], [x, y]]` holds, each pair two finite numbers.
|
||||
fn three_points(v: &Value) -> Option<[Point; 3]> {
|
||||
let pair = |v: &Value| match v.as_array().map(Vec::as_slice) {
|
||||
Some([x, y]) => x.as_f64().zip(y.as_f64()).filter(|(x, y)| x.is_finite() && y.is_finite()).map(|(x, y)| Point::new(x, y)),
|
||||
_ => None,
|
||||
};
|
||||
match v.as_array().map(Vec::as_slice) {
|
||||
Some([a, b, c]) => Some([pair(a)?, pair(b)?, pair(c)?]),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The positions of the selected anchor points, when there are exactly three. They are counted as
|
||||
/// the other anchor commands count them ([`super::path::anchor_targets`]): a selected path with
|
||||
/// anchors picked by Direct Selection gives those, and a path selected whole gives all of its own.
|
||||
/// A selected segment's ends are not selected anchor points, so a selection with segments gives
|
||||
/// none; so does a selection holding an object that is not a path, or an anchor that is gone.
|
||||
fn selected_anchor_points(s: &Session) -> Result<Option<[Point; 3]>> {
|
||||
let st = s.doc()?;
|
||||
if st.selection.segments.values().any(|set| !set.is_empty()) {
|
||||
return Ok(None);
|
||||
}
|
||||
let mut points = Vec::with_capacity(4);
|
||||
for id in &st.selection.objects {
|
||||
let Some(pd) = st.doc.node(*id).and_then(|n| n.path_data()) else { return Ok(None) };
|
||||
match st.selection.anchors.get(id) {
|
||||
Some(set) => {
|
||||
for &(si, ai) in set.iter().take(4) {
|
||||
let Some(a) = pd.subpaths.get(si).and_then(|sp| sp.anchors.get(ai)) else { return Ok(None) };
|
||||
points.push(a.p);
|
||||
}
|
||||
}
|
||||
None => points.extend(pd.anchors().take(4).map(|(_, _, a)| a.p)),
|
||||
}
|
||||
if points.len() > 3 {
|
||||
return Ok(None);
|
||||
}
|
||||
}
|
||||
Ok(match points.as_slice() {
|
||||
&[a, b, c] => Some([a, b, c]),
|
||||
_ => None,
|
||||
})
|
||||
}
|
||||
|
||||
/// The whole-number count `p` gives for `key` (`5` or `5.0`), or `default` when it is left out or
|
||||
/// null. A fraction, a negative, a non-finite or a non-number is an error rather than the default.
|
||||
fn count_or(p: &Value, key: &str, default: u64, cmd: &str) -> Result<u64> {
|
||||
@@ -479,7 +567,7 @@ fn flare(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
None | Some(Value::Null) => Ok(None),
|
||||
Some(v) => v.as_u64().map(Some).ok_or_else(|| bad("shape.flare", format!("`{key}` must be a whole number of at least 0, not {v}"))),
|
||||
};
|
||||
// The generator's state is odd (never 0).
|
||||
// Xorshift64. Both streams start from a nonzero state.
|
||||
let random = |mut state: u64| {
|
||||
move || {
|
||||
state ^= state << 13;
|
||||
@@ -494,7 +582,13 @@ fn flare(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Some(r) if r >= 1 << 53 => return Err(bad("shape.flare", format!("`ringSeed` must be below 2^53, not {r}"))),
|
||||
r => r,
|
||||
};
|
||||
let mut ring_at = ring_seed.map(|r| random((r << 1) | 1));
|
||||
let mut ring_at = ring_seed.map(|r| {
|
||||
// SplitMix64 initializes the ring-position stream.
|
||||
let mut z = r.wrapping_add(0x9e37_79b9_7f4a_7c15);
|
||||
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
|
||||
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
|
||||
random(z ^ (z >> 31))
|
||||
});
|
||||
let stop = |offset: f32, opacity: f32| GradientStop { opacity, ..GradientStop::new(offset, vectorcraft_color::Color::WHITE) };
|
||||
let radial = |centre: Point, radius: f64, stops: Vec<GradientStop>| {
|
||||
let mut g = GradientPaint::new(Gradient::new(GradientKind::Radial, stops));
|
||||
@@ -581,6 +675,10 @@ fn line(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
|
||||
fn spiral(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let rotation = if p.get("rotation").is_some() { f64_req(p, "rotation", "shape.spiral")? } else { 0.0 };
|
||||
if !rotation.is_finite() {
|
||||
return Err(bad("shape.spiral", "rotation must be finite"));
|
||||
}
|
||||
let c = Point::new(f64_req(p, "cx", "shape.spiral")?, f64_req(p, "cy", "shape.spiral")?);
|
||||
let segments = count_or(p, "segments", 10, "shape.spiral")?.clamp(2, 1000) as u32;
|
||||
let path = shapes::spiral(
|
||||
@@ -590,7 +688,15 @@ fn spiral(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
segments,
|
||||
switch_or(p, "clockwise", true, "shape.spiral")?,
|
||||
);
|
||||
add_art(s, "Spiral", path_kind(path, None), None)
|
||||
// The outer end turns clockwise from (cx + radius, cy) about the center; 0 and whole turns
|
||||
// leave the path as it is, and quarter turns are exact.
|
||||
let path = if bbox_turn(rotation) == 0.0 {
|
||||
path
|
||||
} else {
|
||||
let c = c.to_vec2();
|
||||
path.transformed(Affine::translate(c) * vectorcraft_geom::rotate_deg(rotation) * Affine::translate(-c))
|
||||
};
|
||||
add_art_turned(s, "Spiral", path_kind(path, None), constrained_turn(s, rotation))
|
||||
}
|
||||
|
||||
fn arc(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
@@ -651,7 +757,7 @@ fn arc(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if s.paint.stroke.is_none() { vectorcraft_color::Paint::solid(vectorcraft_color::Color::BLACK) } else { s.paint.stroke.clone() },
|
||||
s.paint.stroke_width.max(0.1),
|
||||
);
|
||||
insert_look_turned(s, "Arc", path_kind(path, None), look, None, true, bbox_angle)
|
||||
insert_look_turned(s, "Arc", path_kind(path, None), look, None, true, bbox_angle, true)
|
||||
}
|
||||
|
||||
/// The grid `paths` (bottom first) as one selected group in the new-art stroke, filled with the
|
||||
@@ -831,7 +937,8 @@ fn text_create(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
// Lays the text out (and sizes an Auto Size frame).
|
||||
super::typecmd::refresh_bounds(&mut t);
|
||||
}
|
||||
let made = insert_look_turned(s, "Type", NodeKind::Text(Box::new(t)), NewArt::plain(Appearance::default()), None, true, bbox_turn(rotation))?;
|
||||
let made =
|
||||
insert_look_turned(s, "Type", NodeKind::Text(Box::new(t)), NewArt::plain(Appearance::default()), None, true, bbox_turn(rotation), true)?;
|
||||
let id = made.get("id").and_then(Value::as_u64).map(NodeId);
|
||||
let made = super::typecmd::with_bounds(s, id, made);
|
||||
let mut made = super::typecmd::with_overflow(s, id.as_slice(), made);
|
||||
|
||||
@@ -6,7 +6,7 @@ use std::collections::{BTreeSet, HashMap, HashSet};
|
||||
use std::sync::Arc;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::{CharStyle, Guide, Node, NodeId, NodeKind, SavedSelection, TextKind};
|
||||
use vectorcraft_doc::{CharStyle, Guide, Node, NodeId, NodeKind, SavedSelection, Selection, TextKind};
|
||||
use vectorcraft_geom::Vec2;
|
||||
|
||||
use super::edit::selected_roots;
|
||||
@@ -495,16 +495,17 @@ fn direction_handles(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
}
|
||||
}
|
||||
let total: usize = items.iter().map(|x| x.1.len()).sum();
|
||||
s.select(|_, sel| {
|
||||
sel.clear();
|
||||
for (id, refs) in items {
|
||||
sel.add(id);
|
||||
sel.anchors.insert(id, refs);
|
||||
}
|
||||
})?;
|
||||
s.select(|_, sel| select_anchors(sel, items))?;
|
||||
Ok(json!({ "anchors": total }))
|
||||
}
|
||||
|
||||
/// Replaces `sel` with the paths of `items` in order, each once, and direct-selects the anchors
|
||||
/// listed with each path. A path listed twice keeps its first place and its last anchor set.
|
||||
fn select_anchors(sel: &mut Selection, items: Vec<(NodeId, BTreeSet<(usize, usize)>)>) {
|
||||
sel.set(items.iter().map(|(id, _)| *id));
|
||||
sel.anchors.extend(items);
|
||||
}
|
||||
|
||||
fn save_selection(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
const C: &str = "select.save";
|
||||
let st = s.doc()?;
|
||||
@@ -1026,3 +1027,6 @@ fn close_all(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
}
|
||||
Ok(json!({ "closed": n }))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
@@ -0,0 +1,68 @@
|
||||
//! The selection that Select ▸ Object ▸ Direction Handles builds.
|
||||
|
||||
use std::collections::{BTreeSet, HashSet};
|
||||
use std::sync::Arc;
|
||||
|
||||
use vectorcraft_doc::{NodeId, Selection, SymbolPart};
|
||||
|
||||
use super::select_anchors;
|
||||
|
||||
type Items = Vec<(NodeId, BTreeSet<(usize, usize)>)>;
|
||||
|
||||
/// Selects `items` one path at a time: a clear, then an add and an anchor insert per path.
|
||||
fn one_by_one(sel: &mut Selection, items: Items) {
|
||||
sel.clear();
|
||||
for (id, refs) in items {
|
||||
sel.add(id);
|
||||
sel.anchors.insert(id, refs);
|
||||
}
|
||||
}
|
||||
|
||||
/// A selection with every field set, as one left by earlier selecting.
|
||||
fn busy() -> Selection {
|
||||
let mut sel = Selection::default();
|
||||
sel.set([NodeId(90), NodeId(91)]);
|
||||
sel.anchors.insert(NodeId(90), BTreeSet::from([(0, 0)]));
|
||||
sel.segments.insert(NodeId(91), BTreeSet::from([(0, 1)]));
|
||||
sel.key = Some(NodeId(91));
|
||||
sel.target = Some(NodeId(92));
|
||||
sel.slices = vec![NodeId(93)];
|
||||
sel.guides = vec![NodeId(94)];
|
||||
sel.key_guide = Some(NodeId(94));
|
||||
sel.key_anchor = Some((NodeId(90), (0, 0)));
|
||||
sel.symbol_part = Some(SymbolPart { instance: NodeId(95), path: vec![0, 1] });
|
||||
sel.on_path_member = Some(NodeId(96));
|
||||
sel.new_art = Arc::new(HashSet::from([NodeId(97)]));
|
||||
sel
|
||||
}
|
||||
|
||||
fn refs(n: usize) -> BTreeSet<(usize, usize)> {
|
||||
(0..n).map(|i| (0, i)).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn select_anchors_gives_the_selection_one_by_one_selecting_gives() {
|
||||
let cases: Vec<Items> = vec![
|
||||
vec![],
|
||||
vec![(NodeId(1), refs(4))],
|
||||
(1..=500).map(|i| (NodeId(i), refs(4))).collect(),
|
||||
// A path listed again keeps its first place and its last anchors.
|
||||
vec![(NodeId(3), refs(1)), (NodeId(1), refs(4)), (NodeId(3), refs(2)), (NodeId(2), BTreeSet::new()), (NodeId(1), refs(3))],
|
||||
];
|
||||
for items in cases {
|
||||
for start in [Selection::default(), busy()] {
|
||||
let (mut want, mut got) = (start.clone(), start);
|
||||
one_by_one(&mut want, items.clone());
|
||||
select_anchors(&mut got, items.clone());
|
||||
assert_eq!(got, want, "{items:?}");
|
||||
}
|
||||
}
|
||||
let mut got = busy();
|
||||
select_anchors(&mut got, vec![(NodeId(3), refs(1)), (NodeId(1), refs(4)), (NodeId(3), refs(2))]);
|
||||
assert_eq!(got.objects, vec![NodeId(3), NodeId(1)]);
|
||||
assert_eq!(got.anchors[&NodeId(3)], refs(2));
|
||||
assert!(got.segments.is_empty() && got.slices.is_empty() && got.guides.is_empty());
|
||||
assert_eq!((got.key, got.target, got.key_guide, got.key_anchor, got.on_path_member), (None, None, None, None, None));
|
||||
assert!(got.symbol_part.is_none());
|
||||
assert_eq!(*got.new_art, HashSet::from([NodeId(97)]), "selecting leaves the new-art list alone");
|
||||
}
|
||||
@@ -11,7 +11,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Pencil",
|
||||
[],
|
||||
None,
|
||||
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1: the stroke keeps it, for Calligraphic and Scatter brushes with Pressure variation; a point without one presses fully. Pen tilt in degrees, each −90..90, x positive leaning right and y leaning down the page, and barrel rotation in degrees clockwise, 0..360: the stroke keeps how far the pen leaned, which way and how far its barrel turned, for brushes with Tilt, Bearing and Rotation variation; null for what a point lacks. A pressure, tilt or rotation outside its range, or a point array of more than six numbers, is an error), fidelity?: pt (1.5; from 0.000015625 (0.01 / 640) to 100 / 0.0313 (about 3194.89), the Pencil's and the Paintbrush's 0.01 to 100 px Fidelity at the highest and the lowest zoom; a value outside that range is an error. The tools send their Fidelity in pixels divided by the zoom, kept within the range), fit?: bool (true; false: the points are joined by straight segments, as the Pencil previews a stroke with Live curve fitting off), closed?, style?: \"pencil\"|\"brush\", fill?: bool, keepSelected?: bool (true: the drawn or continued path is selected; false: a new path leaves nothing selected, and a continued or redrawn one is deselected while the rest of the selection stays), extend?: {id, end: \"start\"|\"end\"}, connect?: {id, end: \"start\"|\"end\"}, redraw?: {id, within?: pt (12)}} fit a freehand stroke → {id}. extend continues the path from that end, and closes it when `closed` is true (left out, when the stroke ends within four Fidelities of the path's other end, 6 to 400 pt); with connect, the stroke ends on that end of another path's last open subpath and joins it on, in one path with the extended path's appearance (the other path is removed when nothing of it is left); redraw (Edit Selected Paths) replaces the section of the path between where the stroke starts and ends, each within `within` of one subpath (the shorter way round a closed one), and draws a new path when the stroke doesn't end on it",
|
||||
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1: the stroke keeps it, for Calligraphic and Scatter brushes with Pressure variation; a point without one presses fully. Pen tilt in degrees, each −90..90, x positive leaning right and y leaning down the page, and barrel rotation in degrees clockwise, 0..360: the stroke keeps how far the pen leaned, which way and how far its barrel turned, for brushes with Tilt, Bearing and Rotation variation; null for what a point lacks. A pressure, tilt or rotation outside its range, or a point array of more than six numbers, is an error), fidelity?: pt (1.5; from 0.000015625 (0.01 / 640) to 100 / 0.0313 (about 3194.89), the Pencil's and the Paintbrush's 0.01 to 100 px Fidelity at the highest and the lowest zoom; a value outside that range is an error. The tools send their Fidelity in pixels divided by the zoom, kept within the range), fit?: bool (true; false: the points are joined by straight segments, as the Pencil previews a stroke with Live curve fitting off), closed?, style?: \"pencil\" (default) | \"brush\", fill?: bool, keepSelected?: bool (true: the drawn or continued path is selected; false: a new path leaves nothing selected, and a continued or redrawn one is deselected while the rest of the selection stays), extend?: {id, end?: \"end\" (default) | \"start\"}, connect?: {id, end: \"start\"|\"end\"}, redraw?: {id, within?: pt (12)}} fit a freehand stroke → {id}. extend continues the path from that end, and closes it when `closed` is true (left out, when the stroke ends within four Fidelities of the path's other end, 6 to 400 pt); with connect, the stroke ends on that end of another path's last open subpath and joins it on, in one path with the extended path's appearance (the other path is removed when nothing of it is left); redraw (Edit Selected Paths) replaces the section of the path between where the stroke starts and ends, each within `within` of one subpath (the shorter way round a closed one), and draws a new path when the stroke doesn't end on it. Any other style, extend end or connect end is an error, and nothing changes",
|
||||
has_doc,
|
||||
freehand
|
||||
),
|
||||
@@ -128,7 +128,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Blob Brush",
|
||||
[],
|
||||
None,
|
||||
"{points: [[x,y]…] or [[x,y,pressure]…] (pen pressure 0..1; pen values are checked as path.freehand checks them), size?: pt (10; from 0.1 to 1000), sizeMode?: \"fixed\" (default) | \"pressure\" (Blob Brush Tool Options' Size set to Pressure: the brush is size − sizeVariation wide at the lightest pen pressure and size + sizeVariation at the heaviest, at least 0.1 pt; a stroke without pressure keeps the size), sizeVariation?: pt (0; from 0 to 1000, checked with Fixed too), angle?: ° (0, kept within −180–180: the tip's long axis counter-clockwise from horizontal, kept on the page along the stroke), roundness?: % (100, kept within 0–100: the tip's short axis in percent of its long one, 100 round; 0 is drawn as 0.1), fidelity?: pt (0.01–100; the brush follows the stroke fitted at this tolerance as path.freehand fits a Pencil stroke, and a higher value gives a smoother shape; without it the brush follows every point), merge?: true, mergeOnlySelection?: bool (false: merge with any touching same-color blob; true: only with selected ones), keepSelected?: bool (false: the drawn or merged path is not selected, and the rest of the selection stays; true: it is selected)} filled brush shape, merged with the topmost touching same-color blob and the touching ones next to it in stacking order in its group or layer → {id}",
|
||||
"{points: [[x,y]…] or [[x,y,pressure]…] (pen pressure 0..1; pen values are checked as path.freehand checks them), size?: pt (10; from 0.1 to 1000), sizeMode?: \"fixed\" (default) | \"pressure\" (Blob Brush Tool Options' Size set to Pressure: the brush is size − sizeVariation wide at the lightest pen pressure and size + sizeVariation at the heaviest, at least 0.1 pt; a stroke without pressure keeps the size), sizeVariation?: pt (0; from 0 to 1000, checked with Fixed too), angle?: ° (0, −180–180: the tip's long axis counter-clockwise from horizontal, kept on the page along the stroke), roundness?: % (100, 0–100: the tip's short axis in percent of its long one, 100 round; 0 is drawn as 0.1), fidelity?: pt (0.01–100; the brush follows the stroke fitted at this tolerance as path.freehand fits a Pencil stroke, and a higher value gives a smoother shape; without it the brush follows every point), merge?: true, mergeOnlySelection?: bool (false: merge with any touching same-color blob; true: only with selected ones), keepSelected?: bool (false: the drawn or merged path is not selected, and the rest of the selection stays; true: it is selected)} filled brush shape, merged with the topmost touching same-color blob and the touching ones next to it in stacking order in its group or layer → {id}. An angle, roundness or fidelity outside its range is rejected with an error, and nothing changes",
|
||||
has_doc,
|
||||
blob
|
||||
),
|
||||
|
||||
@@ -200,14 +200,22 @@ pub(crate) fn freehand_brushed(s: &mut Session, p: &Value, brush_name: Option<&s
|
||||
// The tolerance the stroke is fitted at; with `fit: false` it is not fitted.
|
||||
let fit_tol = switch_or(p, "fit", true, C)?.then_some(tol);
|
||||
let closed = switch_or(p, "closed", false, C)?;
|
||||
let brush = str_param(p, "style") == Some("brush");
|
||||
let brush = match p.get("style").filter(|v| !v.is_null()).map(Value::as_str) {
|
||||
None | Some(Some("pencil")) => false,
|
||||
Some(Some("brush")) => true,
|
||||
Some(_) => return Err(bad(C, "style must be \"pencil\" or \"brush\"")),
|
||||
};
|
||||
// The undo step's name: a stroke painted with a brush is a Paintbrush stroke, whatever its style.
|
||||
let label = if brush || brush_name.is_some() { "Paintbrush" } else { "Pencil" };
|
||||
let keep_selected = switch_or(p, "keepSelected", true, C)?;
|
||||
let filled = switch_or(p, "fill", false, C)?;
|
||||
if let Some(ext) = p.get("extend").filter(|v| !v.is_null()) {
|
||||
let id = object_param(ext, "id", C)?.ok_or_else(|| bad(C, "extend needs id"))?;
|
||||
let at_start = str_param(ext, "end") == Some("start");
|
||||
let at_start = match ext.get("end").filter(|v| !v.is_null()).map(Value::as_str) {
|
||||
None | Some(Some("end")) => false,
|
||||
Some(Some("start")) => true,
|
||||
Some(_) => return Err(bad(C, "extend end must be \"start\" or \"end\"")),
|
||||
};
|
||||
let (pd, _) = path_of(&s.doc()?.doc, id)?;
|
||||
let si = pd.subpaths.iter().rposition(|s| !s.closed && !s.anchors.is_empty()).ok_or_else(|| bad(C, "path has no open end"))?;
|
||||
let target = brush_target(&s.doc()?.doc, id);
|
||||
@@ -488,12 +496,23 @@ pub(super) fn blob(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let samples = samples_param(p, "points", C)?;
|
||||
let size = ranged(p, "size", 10.0, SIZES, C)?;
|
||||
let angle = number_or(p, "angle", 0.0, C)?;
|
||||
if !(-180.0..=180.0).contains(&angle) {
|
||||
return Err(bad(C, "`angle` must be from -180 to 180 degrees"));
|
||||
}
|
||||
let roundness = number_or(p, "roundness", 100.0, C)?;
|
||||
if !angle.is_finite() || !roundness.is_finite() {
|
||||
return Err(bad(C, "angle and roundness must be finite"));
|
||||
if !(0.0..=100.0).contains(&roundness) {
|
||||
return Err(bad(C, "`roundness` must be from 0 to 100%"));
|
||||
}
|
||||
// With `fidelity` (pt), the brush follows the stroke fitted by [`fit_freehand`], as a Pencil
|
||||
// stroke is fitted. Without it, or when the fitted stroke has no length (a short stroke back to
|
||||
// its start), the brush follows every point.
|
||||
let fidelity = match p.get("fidelity") {
|
||||
None | Some(Value::Null) => None,
|
||||
Some(_) => Some(number_or(p, "fidelity", 0.0, C)?),
|
||||
};
|
||||
if fidelity.is_some_and(|f| !(vectorcraft_tools::draw2::MIN_FIDELITY..=100.0).contains(&f)) {
|
||||
return Err(bad(C, "`fidelity` must be from 0.01 to 100 pt"));
|
||||
}
|
||||
let angle = angle.clamp(-180.0, 180.0);
|
||||
let roundness = roundness.clamp(0.0, 100.0);
|
||||
let tip = vectorcraft_tools::draw2::blob_tip(angle, roundness);
|
||||
let squash = tip.inverse();
|
||||
// Width profiles use distance along the spine, so measure pressure on the same squashed
|
||||
@@ -515,13 +534,6 @@ pub(super) fn blob(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let mapped_pts: Vec<Point> = mapped_samples.into_iter().map(|s| s.pt).collect();
|
||||
// The widest the brush gets: the area merges look in.
|
||||
let reach = pressure.as_ref().map_or(size, |(_, v)| size + v);
|
||||
// With `fidelity` (pt), the brush follows the stroke fitted by [`fit_freehand`], as a Pencil
|
||||
// stroke is fitted. Without it, or when the fitted stroke has no length (a short stroke back to
|
||||
// its start), the brush follows every point.
|
||||
let fidelity = match p.get("fidelity") {
|
||||
None | Some(Value::Null) => None,
|
||||
Some(_) => Some(number_or(p, "fidelity", 0.0, C)?.clamp(vectorcraft_tools::draw2::MIN_FIDELITY, 100.0)),
|
||||
};
|
||||
let spine = |tol: Option<f64>| {
|
||||
let path = match tol {
|
||||
Some(tol) => PathData::single(fit_freehand(&pts, tol, false)),
|
||||
|
||||
@@ -399,9 +399,7 @@ fn select_found(s: &mut Session, p: &Value, ids: &[NodeId]) -> Result<Value> {
|
||||
let compound = |n: &Node| matches!(n.kind, vectorcraft_doc::NodeKind::Compound { .. });
|
||||
let members = st.isolation.and_then(|i| st.doc.ancestry(i)).is_some_and(|a| a.iter().any(|i| st.doc.node(*i).is_some_and(compound)));
|
||||
let found: BTreeSet<NodeId> = ids.iter().copied().collect();
|
||||
super::select::select_where(s, "document.find", p, |d, n| {
|
||||
found.contains(&n.id) && (members || !d.parent_of(n.id).and_then(|p| d.node(p)).is_some_and(compound))
|
||||
})
|
||||
super::select::select_where(s, "document.find", p, |_, n, parent| found.contains(&n.id) && (members || !parent.is_some_and(compound)))
|
||||
}
|
||||
|
||||
/// Render an artboard at an image's size, drawn as a PNG export draws it (linked images and placed
|
||||
@@ -1189,9 +1187,7 @@ fn clear(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
d.retain_guides(sel, |g| !g.id.is_some_and(|id| gone.contains(&id)));
|
||||
}
|
||||
if is_explicit {
|
||||
for id in &ids {
|
||||
sel.remove(*id);
|
||||
}
|
||||
sel.remove_all(ids.iter().copied());
|
||||
sel.prune(d);
|
||||
} else {
|
||||
sel.clear();
|
||||
|
||||
@@ -1040,7 +1040,8 @@ impl RasterBudget {
|
||||
/// of their own. Random in a Transform effect takes its seed from the id, and the canvas draws the
|
||||
/// pieces with the ids they have before that. `kept` gets the new id of each object in them that
|
||||
/// had an id `skip` lists before. Returns what each of those other members' expansions lists, by
|
||||
/// the member's new id.
|
||||
/// the member's new id. `Err` when such a member still holds a random Transform effect after the
|
||||
/// raster budget left part of it as it is: its new ids would give that effect another seed.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn expand_pieces(
|
||||
d: &mut Document,
|
||||
@@ -1051,7 +1052,7 @@ fn expand_pieces(
|
||||
kept: &mut Vec<NodeId>,
|
||||
stroke_art: effects::StrokeArt,
|
||||
raster: &mut RasterBudget,
|
||||
) -> std::collections::HashMap<NodeId, Vec<Listed>> {
|
||||
) -> std::result::Result<std::collections::HashMap<NodeId, Vec<Listed>>, OverBudget> {
|
||||
let id = m.id;
|
||||
let mut seen = std::collections::HashSet::from([id]);
|
||||
let mut expanded = std::collections::HashMap::new();
|
||||
@@ -1065,7 +1066,12 @@ fn expand_pieces(
|
||||
if all || c.id == id {
|
||||
effects::expand_art(d, c, stroke_art);
|
||||
} else if has_seeded(c) && repeats_an_id(c, &seen) {
|
||||
listed = Some(expand_in_place(d, c, brushes, skip, raster));
|
||||
let left = raster.left;
|
||||
let expanded = expand_in_place(d, c, brushes, skip, raster);
|
||||
if raster.left > left && has_seeded(c) {
|
||||
return Err(OverBudget);
|
||||
}
|
||||
listed = Some(expanded);
|
||||
}
|
||||
let mut was = vec![];
|
||||
if !skip.is_empty() {
|
||||
@@ -1086,7 +1092,7 @@ fn expand_pieces(
|
||||
expanded.insert(c.id, listed);
|
||||
}
|
||||
}
|
||||
expanded
|
||||
Ok(expanded)
|
||||
}
|
||||
|
||||
/// `m`, the art a 3D effect expanded into, with each object in it that has effects of its own (a
|
||||
@@ -1238,6 +1244,82 @@ fn expand_node_except(
|
||||
}
|
||||
}
|
||||
|
||||
/// Replace `n`, a group or layer whose Transform effect's copies each carry the raster effects
|
||||
/// listed before it ([`effects::outer_effects`]), with its art ([`effects::evaluate_container`]):
|
||||
/// the copies become groups of their own with those effects, and they and what they hold get ids
|
||||
/// of their own, so they expand as its members do; the raster effects after the Transform effect
|
||||
/// stay on `n`. A copy that repeats an id ([`repeats_an_id`]) and holds a random Transform effect
|
||||
/// ([`has_seeded`]) expands before its ids change ([`expand_in_place`]), as [`expand_pieces`] does,
|
||||
/// and `members` gets what that expansion lists, by the copy's new id. `kept` gets the new id of
|
||||
/// each copy of an object `skip` lists, and `out` gets `n` unless `listed` says it is there.
|
||||
/// Returns whether `n` changed; any other object stays as it is. `Err`, with `n` as it is, when
|
||||
/// such a copy still holds a random Transform effect after the raster budget left part of it as
|
||||
/// it is: its new ids would give that effect another seed.
|
||||
fn copies_carrying_raster(
|
||||
d: &mut Document,
|
||||
n: &mut Node,
|
||||
(brushes, skip): (&[vectorcraft_brush::Brush], &[NodeId]),
|
||||
kept: &mut Vec<NodeId>,
|
||||
members: &mut std::collections::HashMap<NodeId, Vec<Listed>>,
|
||||
(out, listed): (&mut Vec<Listed>, &mut bool),
|
||||
raster: &mut RasterBudget,
|
||||
) -> std::result::Result<bool, OverBudget> {
|
||||
if !carries_copies(n) {
|
||||
return Ok(false);
|
||||
}
|
||||
let Some(mut m) = effects::evaluate_container(Some(&*d), n) else { return Ok(false) };
|
||||
let mut seen = std::collections::HashSet::from([n.id]);
|
||||
for c in m.children_mut().into_iter().flatten().filter(|c| !c.is_ruler_guide()) {
|
||||
let c = Arc::make_mut(c);
|
||||
let left = raster.left;
|
||||
let mut expanded = (has_seeded(c) && repeats_an_id(c, &seen)).then(|| expand_in_place(d, c, brushes, skip, raster));
|
||||
if expanded.is_some() && raster.left > left && has_seeded(c) {
|
||||
return Err(OverBudget);
|
||||
}
|
||||
let mut was = vec![];
|
||||
if !skip.is_empty() {
|
||||
c.walk(&mut |n| was.push(n.id));
|
||||
}
|
||||
fresh_ids_listed(d, c, &mut seen, expanded.as_deref_mut().unwrap_or_default());
|
||||
// A copy of an object `skip` lists is left as it is too.
|
||||
let mut at = 0;
|
||||
c.walk(&mut |n| {
|
||||
if was.get(at).is_some_and(|old| *old != n.id && skip.contains(old)) {
|
||||
kept.push(n.id);
|
||||
}
|
||||
at += 1;
|
||||
});
|
||||
if let Some(expanded) = expanded {
|
||||
members.insert(c.id, expanded);
|
||||
}
|
||||
}
|
||||
if !*listed {
|
||||
out.push((n.id, 0));
|
||||
*listed = true;
|
||||
}
|
||||
*n = m;
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
/// Is `n` a group or layer whose Transform effect's copies each carry the raster effects listed
|
||||
/// before it ([`copies_carrying_raster`])?
|
||||
fn carries_copies(n: &Node) -> bool {
|
||||
is_container(n) && effects::outer_effects(n).len() != n.appearance.effects.len()
|
||||
}
|
||||
|
||||
/// Does `n`, something in it, or the art of the symbol it places when a color adjustment makes it
|
||||
/// that art, hold a random Transform effect ([`has_seeded`])? The raster budget can then leave `n`
|
||||
/// as it is after part of it expanded ([`expand_pieces`], Crop Marks).
|
||||
fn holds_seeded(d: &Document, n: &Node) -> bool {
|
||||
has_seeded(n)
|
||||
|| match &n.kind {
|
||||
NodeKind::SymbolInstance { symbol, .. } if effects::has_adjustment(n) => {
|
||||
d.symbols.iter().find(|s| s.name == *symbol).is_some_and(|s| has_seeded(&s.art))
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// [`expand_node`] of `n`, which need not be in `d`: `n` with its appearance expanded, `None` when
|
||||
/// it has nothing to expand. `out` gets the objects whose appearance expands, by places in the walk
|
||||
/// of the expanded `n`, `n`'s first when its own does. The objects `skip` lists are not expanded.
|
||||
@@ -1267,10 +1349,23 @@ fn expanded_node(
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
// The embedded images before the adjustment, when the raster budget may yet leave `n` as it
|
||||
// is: the recolored copies the adjustment adds then go again.
|
||||
let images_before = (effects::has_adjustment(&n) && !rasterfx::raster_fx(&n).is_empty())
|
||||
// The embedded images before the adjustment and the expansions of the copies
|
||||
// ([`copies_carrying_raster`]) and of the members that hold a random Transform effect, when the
|
||||
// raster budget may yet leave `n` as it is: the recolored copies and the images those add then
|
||||
// go again.
|
||||
let images_before = ((effects::has_adjustment(&n) && !rasterfx::raster_fx(&n).is_empty()) || carries_copies(&n) || holds_seeded(d, &n))
|
||||
.then(|| d.images.keys().cloned().collect::<std::collections::HashSet<_>>());
|
||||
// What the raster budget had left before those expansions: it gets back what they took.
|
||||
let budget_before = (raster.images, raster.pixels);
|
||||
// `n` stays as it is: `out` lists nothing of it, and the document and the raster budget lose
|
||||
// what expanding it added and took.
|
||||
let leave = |d: &mut Document, out: &mut Vec<Listed>, raster: &mut RasterBudget| {
|
||||
out.truncate(listed_before);
|
||||
if let Some(keys) = &images_before {
|
||||
d.images.retain(|k, _| keys.contains(k));
|
||||
}
|
||||
(raster.images, raster.pixels) = budget_before;
|
||||
};
|
||||
if effects::has_adjustment(&n)
|
||||
&& let Some(m) = effects::adjust_in_document(d, &n, symbol_art)
|
||||
{
|
||||
@@ -1286,14 +1381,21 @@ fn expanded_node(
|
||||
let container = is_container(&n);
|
||||
// Crop Marks: the object and its marks become a group. The object expands on its own first,
|
||||
// with `id`: the canvas draws it with that id, which Random in a Transform effect takes its
|
||||
// seed from. Then the object and the marks get ids of their own.
|
||||
// seed from. Then the object and the marks get ids of their own. When the raster budget leaves
|
||||
// a random Transform effect in the object, `n` stays as it is: new ids would give that effect
|
||||
// another seed.
|
||||
if let Some(mut m) = effects::crop_marks_art(&n) {
|
||||
let mut seen = std::collections::HashSet::from([id]);
|
||||
let mut expanded = vec![];
|
||||
for (i, c) in m.children_mut().into_iter().flatten().enumerate() {
|
||||
let c = Arc::make_mut(c);
|
||||
if i == 0 {
|
||||
let left = raster.left;
|
||||
expanded = expand_in_place(d, c, brushes, skip, raster);
|
||||
if raster.left > left && has_seeded(c) {
|
||||
leave(d, out, raster);
|
||||
return None;
|
||||
}
|
||||
fresh_ids_listed(d, c, &mut seen, &mut expanded);
|
||||
} else {
|
||||
effects::fresh_ids(d, c, &mut seen);
|
||||
@@ -1316,23 +1418,27 @@ fn expanded_node(
|
||||
}
|
||||
return Some(m);
|
||||
}
|
||||
// New ids of the copies of objects `skip` lists among the members.
|
||||
let mut kept = vec![];
|
||||
// Members of a group or layer that `expand_pieces` or `copies_carrying_raster` expanded, by id,
|
||||
// with what their expansion lists.
|
||||
let mut members = std::collections::HashMap::new();
|
||||
let copies = copies_carrying_raster(d, &mut n, (brushes, skip), &mut kept, &mut members, (out, &mut listed_n), raster);
|
||||
// Raster effects whose image would go past the budget stay: so does the object, with what is
|
||||
// inside it and its color adjustments (a symbol instance stays an instance of its symbol).
|
||||
let Ok(image) = raster_image(d, &n, raster) else {
|
||||
out.truncate(listed_before);
|
||||
if let Some(keys) = images_before {
|
||||
d.images.retain(|k, _| keys.contains(k));
|
||||
}
|
||||
// inside it and its color adjustments (a symbol instance stays an instance of its symbol), and
|
||||
// so does a group or layer whose copies or members keep a random Transform effect the budget
|
||||
// left.
|
||||
let Ok(image) = copies.and_then(|copied| {
|
||||
changed |= copied;
|
||||
raster_image(d, &n, raster)
|
||||
}) else {
|
||||
leave(d, out, raster);
|
||||
return None;
|
||||
};
|
||||
let mut v = n.clone();
|
||||
rasterfx::strip_raster(&mut v, false);
|
||||
let mut stroke_art =
|
||||
|d: &mut Document, path: &PathData, rule: FillRule, st: &StrokeLayer| super::pathops::outlined_stroke(d, brushes, path, rule, st);
|
||||
// Members of a group or layer that `expand_pieces` expanded, by id, with what their expansion lists.
|
||||
let mut members = std::collections::HashMap::new();
|
||||
// New ids of the copies of objects `skip` lists among those members.
|
||||
let mut kept = vec![];
|
||||
let expanded = match image {
|
||||
// Blur, feather and inner glow change the object itself: it becomes the image (a layer
|
||||
// keeps it as its only member).
|
||||
@@ -1340,18 +1446,20 @@ fn expanded_node(
|
||||
image => {
|
||||
let m = if (container || matches!(n.kind, NodeKind::Text(_))) && (effects::has_solid(&v) || effects::has_revolve(&v)) {
|
||||
// A 3D effect on a group or layer, or on type: the shaded faces of its solids.
|
||||
effects::expand_leaf(d, &v, &mut stroke_art)
|
||||
Ok::<_, OverBudget>(effects::expand_leaf(d, &v, &mut stroke_art))
|
||||
} else if container {
|
||||
// A group's or layer's own fills and strokes become art among its members.
|
||||
effects::evaluate_container(Some(&*d), &v).map(|mut m| {
|
||||
members = expand_pieces(d, &mut m, false, brushes, skip, &mut kept, &mut stroke_art, raster);
|
||||
m
|
||||
})
|
||||
effects::evaluate_container(Some(&*d), &v)
|
||||
.map(|mut m| {
|
||||
members.extend(expand_pieces(d, &mut m, false, brushes, skip, &mut kept, &mut stroke_art, raster)?);
|
||||
Ok(m)
|
||||
})
|
||||
.transpose()
|
||||
} else if matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. })
|
||||
&& !effects::has_transform_art(&v)
|
||||
&& !effects::has_transform_copies(&v)
|
||||
{
|
||||
effects::expand_leaf(d, &v, &mut stroke_art)
|
||||
Ok(effects::expand_leaf(d, &v, &mut stroke_art))
|
||||
} else {
|
||||
// Type, images, symbol instances, live objects (and paths whose Transform effect copies
|
||||
// them, each copy an object of its own, or changes their fills and strokes): through
|
||||
@@ -1367,12 +1475,18 @@ fn expanded_node(
|
||||
let row_raster = image.is_some() && effects::has_instance_row_raster(&n);
|
||||
let outlined = effects::expand_outlined(Some(&*d), &v, symbol.as_ref())
|
||||
.or_else(|| if row_raster { effects::instance_as_art(Some(&*d), &v, symbol.as_ref()) } else { None });
|
||||
outlined.map(|mut m| {
|
||||
let mut budget = vectorcraft_doc::MAX_SYMBOL_NODES;
|
||||
expand_nested_instances(d, &mut m, 1, &mut budget, raster);
|
||||
expand_pieces(d, &mut m, true, brushes, skip, &mut kept, &mut stroke_art, raster);
|
||||
m
|
||||
})
|
||||
outlined
|
||||
.map(|mut m| {
|
||||
let mut budget = vectorcraft_doc::MAX_SYMBOL_NODES;
|
||||
expand_nested_instances(d, &mut m, 1, &mut budget, raster);
|
||||
expand_pieces(d, &mut m, true, brushes, skip, &mut kept, &mut stroke_art, raster)?;
|
||||
Ok(m)
|
||||
})
|
||||
.transpose()
|
||||
};
|
||||
let Ok(m) = m else {
|
||||
leave(d, out, raster);
|
||||
return None;
|
||||
};
|
||||
// A 3D effect's shadow blurred by the light's Softness keeps its blur in the art: it
|
||||
// expands in turn, to an image.
|
||||
|
||||
@@ -1150,3 +1150,129 @@ fn an_image_past_the_pixels_left_stays_unmade() {
|
||||
let mut budget = super::RasterBudget { images: 0, pixels, left: 0 };
|
||||
assert!(super::raster_image(&mut d, &n, &mut budget).is_err(), "no image is left");
|
||||
}
|
||||
|
||||
/// A group whose Transform effect's copies each carry the drop shadow listed before it, with a
|
||||
/// symbol instance whose random Transform effect takes its seed from the instance's id, stays as it
|
||||
/// is when the raster budget has no image left for a copy's shadow, with none left or with one for
|
||||
/// the first copy's: the copies keep the ids their random moves are drawn with, the group draws as
|
||||
/// before, and the document holds no image the first copy's expansion made, nor the budget its
|
||||
/// charge.
|
||||
#[test]
|
||||
fn copies_the_raster_budget_leaves_keep_their_random_moves() {
|
||||
let (mut s, id) = session_with_rect();
|
||||
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
|
||||
let id = NodeId(s.execute("symbol.new", &json!({"name": "Box"})).unwrap()["id"].as_u64().unwrap());
|
||||
let random = json!({"moveH": 40, "moveV": 40, "random": true});
|
||||
s.execute("effect.apply", &json!({"ids": [id.0], "effect": "distort.transform", "params": random})).unwrap();
|
||||
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
|
||||
let g = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap());
|
||||
let shadow = json!({"x": 10, "y": 0, "blur": 0, "opacity": 100, "mode": "normal", "color": "#00ff00"});
|
||||
s.execute("effect.apply", &json!({"ids": [g.0], "effect": "stylize.dropShadow", "params": shadow})).unwrap();
|
||||
s.execute("effect.apply", &json!({"ids": [g.0], "effect": "distort.transform", "params": {"moveV": 150, "copies": 1}})).unwrap();
|
||||
let draw = |d: &vectorcraft_doc::Document| {
|
||||
vectorcraft_render::Renderer::new().render(d, 400, 400, vectorcraft_geom::Affine::IDENTITY, &Default::default()).pixels
|
||||
};
|
||||
for images in [0, 1] {
|
||||
let mut d = s.doc().unwrap().doc.as_ref().clone();
|
||||
let before = d.node(g).cloned().unwrap();
|
||||
assert!(effects::outer_effects(&before).len() < before.appearance.effects.len(), "each copy carries the shadow");
|
||||
let (drawn, keys) = (draw(&d), d.images.keys().cloned().collect::<Vec<_>>());
|
||||
|
||||
let mut budget = super::RasterBudget { images, pixels: u64::MAX, left: 0 };
|
||||
let mut out = vec![];
|
||||
super::expand_node(&mut d, g, &[], &mut out, &mut budget);
|
||||
assert!(budget.left > 0, "{images}: a copy's shadow is left");
|
||||
assert!(out.is_empty(), "{images}: nothing expands: {out:?}");
|
||||
assert_eq!(d.node(g), Some(&before), "{images}: the group stays as it is");
|
||||
assert!(draw(&d) == drawn, "{images}: the group draws as before");
|
||||
assert_eq!(d.images.keys().cloned().collect::<Vec<_>>(), keys, "{images}: no image is added");
|
||||
assert_eq!((budget.images, budget.pixels), (images, u64::MAX), "{images}: the budget gets back what the copies took");
|
||||
}
|
||||
}
|
||||
|
||||
/// A group whose Transform effect copies its symbol instance, which has a drop shadow and a random
|
||||
/// Transform effect that takes its seed from the instance's id: each copy's instance has that id.
|
||||
/// When the raster budget has no image left for a copy's shadow, with none left or with one for the
|
||||
/// first copy's, the group stays as it is: the copies keep the ids their random moves are drawn
|
||||
/// with, the group draws as before, and the document holds no image the first copy's expansion
|
||||
/// made, nor the budget its charge. With the whole budget, the group expands and each object gets
|
||||
/// an id of its own.
|
||||
#[test]
|
||||
fn a_member_the_raster_budget_leaves_keeps_its_random_move() {
|
||||
let (mut s, id) = session_with_rect();
|
||||
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
|
||||
let id = NodeId(s.execute("symbol.new", &json!({"name": "Box"})).unwrap()["id"].as_u64().unwrap());
|
||||
let shadow = json!({"x": 10, "y": 0, "blur": 0, "opacity": 100, "mode": "normal", "color": "#00ff00"});
|
||||
s.execute("effect.apply", &json!({"ids": [id.0], "effect": "stylize.dropShadow", "params": shadow})).unwrap();
|
||||
let random = json!({"moveH": 40, "moveV": 40, "random": true});
|
||||
s.execute("effect.apply", &json!({"ids": [id.0], "effect": "distort.transform", "params": random})).unwrap();
|
||||
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
|
||||
let g = NodeId(s.execute("object.group", &json!({})).unwrap()["id"].as_u64().unwrap());
|
||||
s.execute("effect.apply", &json!({"ids": [g.0], "effect": "distort.transform", "params": {"moveV": 150, "copies": 1}})).unwrap();
|
||||
let draw = |d: &vectorcraft_doc::Document| {
|
||||
vectorcraft_render::Renderer::new().render(d, 400, 400, vectorcraft_geom::Affine::IDENTITY, &Default::default()).pixels
|
||||
};
|
||||
for images in [0, 1, 1_024] {
|
||||
let mut d = s.doc().unwrap().doc.as_ref().clone();
|
||||
let before = d.node(g).cloned().unwrap();
|
||||
assert!(effects::outer_effects(&before).len() == before.appearance.effects.len(), "the copies carry no shadow of the group's");
|
||||
let art = effects::evaluate_container(Some(&d), &before).unwrap();
|
||||
let mut instances = 0;
|
||||
art.walk(&mut |n| instances += usize::from(n.id == id && super::has_seeded(n)));
|
||||
assert!(instances >= 2, "{images}: each copy's instance has the id and its random effect: {instances}");
|
||||
let (drawn, keys) = (draw(&d), d.images.keys().cloned().collect::<Vec<_>>());
|
||||
|
||||
let mut budget = super::RasterBudget { images, pixels: u64::MAX, left: 0 };
|
||||
let mut out = vec![];
|
||||
super::expand_node(&mut d, g, &[], &mut out, &mut budget);
|
||||
if images < 2 {
|
||||
assert!(budget.left > 0, "{images}: a shadow is left");
|
||||
assert!(out.is_empty(), "{images}: nothing expands: {out:?}");
|
||||
assert_eq!(d.node(g), Some(&before), "{images}: the group stays as it is");
|
||||
assert!(draw(&d) == drawn, "{images}: the group draws as before");
|
||||
assert_eq!(d.images.keys().cloned().collect::<Vec<_>>(), keys, "{images}: no image is added");
|
||||
assert_eq!((budget.images, budget.pixels), (images, u64::MAX), "{images}: the budget gets back what the copies took");
|
||||
} else {
|
||||
assert_eq!(budget.left, 0, "no shadow is left");
|
||||
assert!(!out.is_empty(), "the group expands");
|
||||
let (mut ids, mut count, mut seeded) = (std::collections::HashSet::new(), 0, false);
|
||||
d.node(g).unwrap().walk(&mut |n| {
|
||||
ids.insert(n.id);
|
||||
count += 1;
|
||||
seeded |= super::has_seeded(n);
|
||||
});
|
||||
assert_eq!(ids.len(), count, "each object has an id of its own");
|
||||
assert!(!seeded, "no random Transform effect is left");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An object with Crop Marks, a drop shadow and a random Transform effect that takes its seed from
|
||||
/// the object's id stays as it is when the raster budget has no image left for its shadow: the
|
||||
/// object keeps its id and its random move, and draws as before.
|
||||
#[test]
|
||||
fn crop_marks_the_raster_budget_leaves_keep_their_random_move() {
|
||||
let (mut s, id) = session_with_rect();
|
||||
let shadow = json!({"x": 10, "y": 0, "blur": 0, "opacity": 100, "mode": "normal", "color": "#00ff00"});
|
||||
s.execute("effect.apply", &json!({"ids": [id.0], "effect": "stylize.dropShadow", "params": shadow})).unwrap();
|
||||
let random = json!({"moveH": 40, "moveV": 40, "random": true});
|
||||
s.execute("effect.apply", &json!({"ids": [id.0], "effect": "distort.transform", "params": random})).unwrap();
|
||||
s.execute("effect.apply", &json!({"ids": [id.0], "effect": "cropMarks", "params": {}})).unwrap();
|
||||
let draw = |d: &vectorcraft_doc::Document| {
|
||||
vectorcraft_render::Renderer::new().render(d, 400, 400, vectorcraft_geom::Affine::IDENTITY, &Default::default()).pixels
|
||||
};
|
||||
let mut d = s.doc().unwrap().doc.as_ref().clone();
|
||||
let before = d.node(id).cloned().unwrap();
|
||||
assert!(effects::crop_marks_art(&before).is_some(), "the object has crop marks");
|
||||
let (drawn, keys) = (draw(&d), d.images.keys().cloned().collect::<Vec<_>>());
|
||||
|
||||
let mut budget = super::RasterBudget { images: 0, pixels: u64::MAX, left: 0 };
|
||||
let mut out = vec![];
|
||||
super::expand_node(&mut d, id, &[], &mut out, &mut budget);
|
||||
assert!(budget.left > 0, "the shadow is left");
|
||||
assert!(out.is_empty(), "nothing expands: {out:?}");
|
||||
assert_eq!(d.node(id), Some(&before), "the object stays as it is");
|
||||
assert!(draw(&d) == drawn, "the object draws as before");
|
||||
assert_eq!(d.images.keys().cloned().collect::<Vec<_>>(), keys, "no image is added");
|
||||
assert_eq!((budget.images, budget.pixels), (0, u64::MAX), "the budget is as it was");
|
||||
}
|
||||
|
||||
@@ -39,7 +39,7 @@ pub mod jxlread;
|
||||
mod legacy_ai;
|
||||
mod load;
|
||||
mod mesh3d;
|
||||
pub(crate) use load::{MAX_RASTER_ALLOC, file_clipped, png_clip, size_note};
|
||||
pub(crate) use load::{MAX_RASTER_ALLOC, file_clipped, image_clip, size_note};
|
||||
mod heifread;
|
||||
mod hpgl;
|
||||
mod jp2read;
|
||||
@@ -87,8 +87,10 @@ pub use load::{
|
||||
};
|
||||
pub(crate) use load::{check_files_not_lossy_overwrite, check_not_lossy_overwrite, lossy_source};
|
||||
pub use load::{losses_summary, overwrite_losses};
|
||||
pub use mesh3d::{DEFAULT_FORMAT_3D, FORMATS_3D, format_3d_label};
|
||||
pub(crate) use mesh3d::{mesh_file_names, mesh_files};
|
||||
#[cfg(test)]
|
||||
pub(crate) use mesh3d::MAX_TEXTURE_PIXELS;
|
||||
pub use mesh3d::{DEFAULT_FORMAT_3D, FORMATS_3D, draws_textures, format_3d_label};
|
||||
pub(crate) use mesh3d::{TEXTURE_SIZE, TEXTURE_SIZES, image_maps, mesh_file_names, mesh_files, textures};
|
||||
pub use naming::{NameParts as FileNameParts, parse_date as parse_file_date, render as render_file_name};
|
||||
pub(crate) use native::preview_png;
|
||||
pub use native::with_compression_pref;
|
||||
|
||||
File diff suppressed because one or more lines are too long
@@ -241,7 +241,8 @@ struct RasterOptions {
|
||||
width: Option<f64>,
|
||||
/// The height of each file in pixels (wins over `ppi` and `scale`).
|
||||
height: Option<f64>,
|
||||
quality: Option<u8>,
|
||||
/// JPEG and lossy WebP quality, read by [`RasterOptions::quality`].
|
||||
quality: Option<Value>,
|
||||
background: Option<Value>,
|
||||
anti_alias: Option<String>,
|
||||
interlaced: Option<bool>,
|
||||
@@ -281,6 +282,19 @@ fn clamped_ppi(ppi: f64) -> f64 {
|
||||
}
|
||||
|
||||
impl RasterOptions {
|
||||
/// `quality` as given: `None` when absent or null, else a whole number 0–255 (JPEG caps it at
|
||||
/// 100; WebP refuses more than 100), or an error naming it.
|
||||
fn quality(&self) -> Result<Option<u8>> {
|
||||
match &self.quality {
|
||||
None | Some(Value::Null) => Ok(None),
|
||||
Some(v) => v
|
||||
.as_u64()
|
||||
.and_then(|q| u8::try_from(q).ok())
|
||||
.map(Some)
|
||||
.ok_or_else(|| bad(C, format!("quality must be a whole number from 0 to 100, not {v}"))),
|
||||
}
|
||||
}
|
||||
|
||||
/// The pixel size each file is scaled to: `width`, else `height`; `None` when neither is set.
|
||||
fn pixel_size(&self) -> Result<Option<ScreenSize>> {
|
||||
let checked = |key: &str, n: f64| {
|
||||
@@ -311,7 +325,8 @@ impl RasterOptions {
|
||||
},
|
||||
anti_alias: self.anti_alias.as_deref().map(anti_alias).transpose().map_err(|e| bad(C, e))?.unwrap_or_default(),
|
||||
interlaced: self.interlaced.unwrap_or(false),
|
||||
quality: self.quality.unwrap_or(90).min(100),
|
||||
quality: self.quality()?.unwrap_or(90).min(100),
|
||||
webp_lossless: self.lossless.unwrap_or(true),
|
||||
jpeg: JpegOptions {
|
||||
color_model,
|
||||
method: parse(self.method.as_deref(), jpeg::Method::from_id, "method", "baseline, optimized or progressive")?,
|
||||
@@ -1136,6 +1151,11 @@ fn encode_files(doc: &Document, f: &Format, p: &Value) -> Result<Encoded> {
|
||||
"psd" => RasterFormat::Psd,
|
||||
_ => RasterFormat::WebP,
|
||||
};
|
||||
if format == RasterFormat::WebP
|
||||
&& let Some(q) = o.quality()?.filter(|q| *q > 100)
|
||||
{
|
||||
return Err(bad(C, format!("quality {q}: WebP quality is 0–100")));
|
||||
}
|
||||
check_options(format, &settings)?;
|
||||
// Use Artboards: one file per chosen artboard (default all); else the one chosen.
|
||||
let chosen = match use_artboards {
|
||||
@@ -1182,9 +1202,6 @@ fn encode_files(doc: &Document, f: &Format, p: &Value) -> Result<Encoded> {
|
||||
}
|
||||
let regions: Vec<Rect> = enc.files.iter().filter_map(|(b, _)| b.and_then(|b| doc.artboards.get(b))).map(|a| a.rect).collect();
|
||||
enc.warnings.extend(crate::cmd::fonts::export_overflow_warning(doc, &doc.layers, Some(®ions)));
|
||||
if format == RasterFormat::WebP && o.lossless == Some(false) {
|
||||
enc.setting_notes.push("lossy WebP isn't available yet: the file is lossless (exact, but larger)".into());
|
||||
}
|
||||
return Ok(enc);
|
||||
}
|
||||
_ => return Err(bad(C, format!("no encoder for {} yet", f.label))),
|
||||
|
||||
@@ -211,17 +211,11 @@ fn selected_part(n: &Arc<Node>, keep: &HashSet<NodeId>, holders: &HashSet<NodeId
|
||||
/// its own art, not a whole document of artboards. `renderer` measures the 3D art, and keeps it for
|
||||
/// the next artboard of the same document.
|
||||
pub(super) fn art_over(doc: &Document, rect: vectorcraft_geom::Rect, renderer: &mut vectorcraft_render::Renderer) -> Document {
|
||||
fn kept(
|
||||
n: &Arc<Node>,
|
||||
doc: &Document,
|
||||
symbols: &SymbolBoxes,
|
||||
rect: vectorcraft_geom::Rect,
|
||||
renderer: &mut vectorcraft_render::Renderer,
|
||||
) -> Option<Arc<Node>> {
|
||||
fn kept(n: &Arc<Node>, symbols: &SymbolBoxes, rect: vectorcraft_geom::Rect, renderer: &mut vectorcraft_render::Renderer) -> Option<Arc<Node>> {
|
||||
if matches!(n.kind, NodeKind::Layer { clip: false, .. }) {
|
||||
let mut layer = Node::clone(n);
|
||||
let children = layer.children_mut()?;
|
||||
*children = children.iter().filter_map(|c| kept(c, doc, symbols, rect, renderer)).collect();
|
||||
*children = children.iter().filter_map(|c| kept(c, symbols, rect, renderer)).collect();
|
||||
return Some(Arc::new(layer));
|
||||
}
|
||||
// A group that doesn't clip keeps only its members over the artboard, so art gathered in one
|
||||
@@ -230,20 +224,21 @@ pub(super) fn art_over(doc: &Document, rect: vectorcraft_geom::Rect, renderer: &
|
||||
if matches!(n.kind, NodeKind::Group { clip: false, .. }) && n.appearance.effects.is_empty() {
|
||||
let mut group = Node::clone(n);
|
||||
let children = group.children_mut()?;
|
||||
*children = children.iter().filter_map(|c| kept(c, doc, symbols, rect, renderer)).collect();
|
||||
*children = children.iter().filter_map(|c| kept(c, symbols, rect, renderer)).collect();
|
||||
return (!children.is_empty()).then(|| Arc::new(group));
|
||||
}
|
||||
let over = |b: vectorcraft_geom::Rect| b.x0 <= rect.x1 && rect.x0 <= b.x1 && b.y0 <= rect.y1 && rect.y0 <= b.y1;
|
||||
let mut holds_instance = false;
|
||||
n.walk(&mut |c| holds_instance |= matches!(c.kind, NodeKind::SymbolInstance { .. }));
|
||||
let painted = || holds_instance && vectorcraft_render::painted_bounds(doc, n).is_some_and(over);
|
||||
// Measured in boxes of its own, which find symbols through the same index.
|
||||
let painted = || holds_instance && vectorcraft_render::painted_bounds_with(&symbols.unmeasured(), n).is_some_and(over);
|
||||
let reach = vectorcraft_brush::reach_within(n);
|
||||
let brushed = |b: vectorcraft_geom::Rect| over(if reach > 0.0 { b.inflate(reach, reach) } else { b });
|
||||
(n.visual_bounds_with(symbols).is_none_or(brushed) || renderer.effect_bounds(symbols, n).is_some_and(brushed) || painted()).then(|| n.clone())
|
||||
}
|
||||
let symbols = doc.symbol_boxes().with_brush_art();
|
||||
let mut d = doc.clone();
|
||||
d.layers = doc.layers.iter().filter_map(|l| kept(l, doc, &symbols, rect, renderer)).collect();
|
||||
d.layers = doc.layers.iter().filter_map(|l| kept(l, &symbols, rect, renderer)).collect();
|
||||
d
|
||||
}
|
||||
|
||||
|
||||
@@ -206,11 +206,15 @@ const LOSSLESS: FormatOption = FormatOption {
|
||||
name: "lossless",
|
||||
ty: "boolean",
|
||||
default: "true",
|
||||
description: "lossless WebP; false asks for lossy, which isn't available yet (written lossless, with a warning)",
|
||||
description: "lossless WebP (every pixel kept exactly); false writes lossy WebP at quality: a smaller file that loses some detail",
|
||||
};
|
||||
|
||||
const WEBP_QUALITY: FormatOption =
|
||||
FormatOption { name: "quality", ty: "integer", default: "90", description: "lossy quality 0–100 (for when lossy WebP is available)" };
|
||||
const WEBP_QUALITY: FormatOption = FormatOption {
|
||||
name: "quality",
|
||||
ty: "integer",
|
||||
default: "90",
|
||||
description: "lossy WebP quality 0–100 (with lossless false; higher keeps more detail in a larger file; more than 100 is refused)",
|
||||
};
|
||||
|
||||
/// The options of the palette formats (PNG-8, GIF).
|
||||
const PALETTE_OPTIONS: &[FormatOption] = &[
|
||||
|
||||
@@ -60,8 +60,7 @@ impl Loaded {
|
||||
}
|
||||
}
|
||||
|
||||
/// An image ready to embed: PNG/JPEG/GIF/WebP keep their bytes, other formats are stored as PNG
|
||||
/// (what browsers, PDF and SVG viewers show).
|
||||
/// An image ready to embed. CMYK images use JPEG or TIFF; other images use browser-readable formats.
|
||||
#[derive(Clone)]
|
||||
pub struct RasterImage {
|
||||
/// Content key for `Document::images` (identical files share one blob).
|
||||
@@ -286,16 +285,24 @@ fn editing_copy(opened: &vectorcraft_pdf::Opened, opts: &LoadOptions) -> Option<
|
||||
|
||||
/// A `.ai`, or a PDF saved with the editing data, whose PDF part can't be read (`e`, the import's
|
||||
/// error) from the editor's own copy of its art alone, as a file saved without PDF compatibility
|
||||
/// is read, its first note saying why: `None` when pages are picked, layers or the editing data
|
||||
/// are off, or the file has no editing data that reads. Its type is outlines when `opts` asks.
|
||||
fn without_pdf_part(bytes: &[u8], opts: &LoadOptions, e: &EngineError) -> Option<(Document, Vec<String>)> {
|
||||
/// is read, its first note saying why. Else `e`: as it is when pages are picked, layers or the
|
||||
/// editing data are off, or the file has no editing data, and followed by why when the file has
|
||||
/// editing data that can't be read. Its type is outlines when `opts` asks.
|
||||
fn without_pdf_part(bytes: &[u8], opts: &LoadOptions, e: EngineError) -> Result<(Document, Vec<String>)> {
|
||||
if opts.pages.is_some() || !opts.layers || !opts.editing_data {
|
||||
return None;
|
||||
return Err(e);
|
||||
}
|
||||
let read = vectorcraft_pdf::read_illustrator_data_without_pdf_part(bytes, opts.password.as_deref())
|
||||
.and_then(|private| private.map(|p| vectorcraft_eps::ai_alone_on_page(&p.data, p.trim, p.user_unit, opts.legacy_names)).transpose());
|
||||
match read {
|
||||
Ok(Some((doc, warnings))) => {
|
||||
let notes =
|
||||
std::iter::once(format!("the PDF part couldn't be read ({e}): the file opened from its editing data")).chain(warnings).collect();
|
||||
Ok(outlined_if_asked(doc, notes, opts))
|
||||
}
|
||||
Ok(None) => Err(e),
|
||||
Err(why) => Err(err(format!("{e}; its editing data couldn't be read either ({why})"))),
|
||||
}
|
||||
let private = vectorcraft_pdf::illustrator_data_without_pdf_part(bytes, opts.password.as_deref())?;
|
||||
let (doc, warnings) = vectorcraft_eps::ai_alone_on_page(&private.data, private.trim, private.user_unit, opts.legacy_names).ok()?;
|
||||
let notes = std::iter::once(format!("the PDF part couldn't be read ({e}): the file opened from its editing data")).chain(warnings).collect();
|
||||
Some(outlined_if_asked(doc, notes, opts))
|
||||
}
|
||||
|
||||
/// Is `w` a note on the PDF part as a page, which says nothing was skipped: that the art off the
|
||||
@@ -497,7 +504,7 @@ pub fn load_with(name: &str, bytes: &[u8], opts: &LoadOptions) -> Result<Loaded>
|
||||
.inspect(|_| editing_data = true),
|
||||
// A PDF part that can't be read (a stream the import refuses): the editing copy
|
||||
// alone where it reads, else the error.
|
||||
Err(e) => without_pdf_part(bytes, opts, &e).inspect(|_| editing_data = true).ok_or(e),
|
||||
Err(e) => without_pdf_part(bytes, opts, e).inspect(|_| editing_data = true),
|
||||
}
|
||||
})?;
|
||||
// The File Info of a file read from its pages or its editing copy.
|
||||
@@ -929,8 +936,9 @@ pub(crate) fn size_note(bytes: &[u8]) -> Option<String> {
|
||||
/// ink are written again with their inks together ([`vectorcraft_doc::cmyk::stored_cmyk_tiff`]);
|
||||
/// CMYK TIFFs with an alpha channel, which the decoder can't read, become RGBA in the active color
|
||||
/// settings' CMYK, whichever of their extra channels is the alpha
|
||||
/// ([`vectorcraft_doc::cmyk::extra_samples_tiff_rgba`]), as do CMYK Photoshop documents, whose
|
||||
/// merged image is read ([`psdread`]).
|
||||
/// ([`vectorcraft_doc::cmyk::extra_samples_tiff_rgba`]). Opaque CMYK PSD/PSB merged images retain
|
||||
/// 8- or 16-bit inks and their CMYK ICC profile as TIFF, within the native CMYK pixel and allocation limits;
|
||||
/// other CMYK composites use the RGBA decoder's allocation limit ([`psdread`]).
|
||||
/// 1-bit TIFFs compressed with CCITT Group 3, which the decoder can't read either, become RGBA
|
||||
/// too ([`vectorcraft_doc::cmyk::group3_tiff_rgba`]).
|
||||
/// Grayscale TIFFs with an alpha channel or other extra channels, which the decoder can't read
|
||||
@@ -953,14 +961,27 @@ pub(crate) fn size_note(bytes: &[u8]) -> Option<String> {
|
||||
/// or TIFF keeps its inks, at the 8 or 16 bits the file has, and its CMYK ICC profile as a CMYK
|
||||
/// TIFF ([`vectorcraft_doc::cmyk::turned_cmyk`]). An image the decoder reads and that is stored as
|
||||
/// PNG keeps its gray or RGB samples at 8 or 16 bits, and the gray or RGB ICC profile they are in;
|
||||
/// other samples become 8-bit RGBA. A Photoshop document's PNG keeps the clipping path the file
|
||||
/// names ([`png_with_clip`]).
|
||||
/// other samples become 8-bit RGBA. A PSD/PSB composite's stored image keeps its imported
|
||||
/// clipping path ([`image_clip`]).
|
||||
pub fn raster_image(bytes: &[u8]) -> Result<RasterImage> {
|
||||
let ppi = super::ppi::resolution(bytes);
|
||||
if let Some((w, h)) = vectorcraft_doc::cmyk::oversized_tiff(bytes) {
|
||||
return Err(err(format!("an image of {w} × {h} pixels is too large to draw")));
|
||||
}
|
||||
if psdread::is_psd(bytes) {
|
||||
if let Some(mut native) = psdread::decode_cmyk(bytes, MAX_RASTER_ALLOC).map_err(err)? {
|
||||
native.meta.dpi = ppi.map(|(x, y)| (x as f32, y as f32));
|
||||
let clip = psdread::clipping_path(bytes).and_then(|path| {
|
||||
let json = serde_json::to_string(&path).ok().filter(|j| j.len() <= MAX_PNG_CLIP)?;
|
||||
native.meta.text.push(("Description".into(), format!("{CLIP_KEYWORD}\n{json}")));
|
||||
Some((path, vectorcraft_geom::FillRule::EvenOdd))
|
||||
});
|
||||
let data =
|
||||
craft_image_codecs::encode(&native, craft_image_codecs::Format::Tiff, &craft_image_codecs::EncodeOptions::default()).map_err(err)?;
|
||||
let mut img = stored(data, "image/tiff", native.dimensions(), ppi)?;
|
||||
img.clip = clip;
|
||||
return Ok(img);
|
||||
}
|
||||
let cms = vectorcraft_color::cms::active();
|
||||
let img = as_png(psdread::decode(bytes, MAX_RASTER_ALLOC, |c| cms.cmyk_to_srgb(c, false)).map_err(err)?, None, ppi)?;
|
||||
return Ok(png_with_clip(img, psdread::clipping_path(bytes)));
|
||||
@@ -1165,6 +1186,31 @@ pub(crate) fn png_clip(png: &[u8]) -> Option<vectorcraft_geom::PathData> {
|
||||
vectorcraft_geom::path::with_anchor_budget(vectorcraft_geom::path::MAX_READ_ANCHORS, || serde_json::from_slice(json).ok())
|
||||
}
|
||||
|
||||
/// The imported clipping-path marker in a stored PNG or CMYK TIFF, within the path budget.
|
||||
pub(crate) fn image_clip(blob: &ImageBlob) -> Option<vectorcraft_geom::PathData> {
|
||||
if blob.mime == "image/png" {
|
||||
return png_clip(&blob.bytes);
|
||||
}
|
||||
if blob.mime != "image/tiff" {
|
||||
return None;
|
||||
}
|
||||
use tiff::tags::{Tag, Type, ValueBuffer};
|
||||
let mut d = tiff::decoder::Decoder::new(std::io::Cursor::new(blob.bytes.as_slice())).ok()?;
|
||||
let mut ifd = d.image_ifd();
|
||||
let entry = ifd.find_entry(Tag::ImageDescription)?;
|
||||
if entry.field_type() != Type::ASCII || entry.count() > (MAX_PNG_CLIP + CLIP_KEYWORD.len() + 2) as u64 {
|
||||
return None;
|
||||
}
|
||||
let mut buf = ValueBuffer::empty(Type::ASCII);
|
||||
ifd.find_tag_buf(Tag::ImageDescription, &mut buf).ok()??;
|
||||
let json = buf.as_bytes().strip_prefix(CLIP_KEYWORD.as_bytes())?.strip_prefix(b"\n")?;
|
||||
let json = json.strip_suffix(b"\0").unwrap_or(json);
|
||||
if json.len() > MAX_PNG_CLIP {
|
||||
return None;
|
||||
}
|
||||
vectorcraft_geom::path::with_anchor_budget(vectorcraft_geom::path::MAX_READ_ANCHORS, || serde_json::from_slice(json).ok())
|
||||
}
|
||||
|
||||
/// An image as a document of its physical size at the resolution it declares (as Place sizes it;
|
||||
/// 72 ppi, 1 px = 1 pt, when it declares none), the image named after the file.
|
||||
pub(super) fn raster_doc(name: &str, bytes: &[u8]) -> Result<Document> {
|
||||
|
||||
@@ -9,13 +9,24 @@
|
||||
//! as their specifications ask; MTL colors are the display colors. Materials are two-sided, since
|
||||
//! an open solid or a turned plane is seen from both sides.
|
||||
//!
|
||||
//! The graphics mapped onto a face of a solid ([`textures`]) are a PNG picture of that face: its
|
||||
//! color with the graphics drawn over it, flat and unshaded, which the face's own mesh shows through
|
||||
//! texture coordinates and a material of its own. glTF embeds each PNG as a data URI, USDZ stores it
|
||||
//! after the layer, and OBJ and USDA name PNG files written beside them (`<name>-texture-1.png`…).
|
||||
//!
|
||||
//! Formats: glTF 2.0 <https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html>, USD
|
||||
//! <https://openusd.org/release/index.html> (USDZ: <https://openusd.org/release/spec_usdz.html>).
|
||||
//! <https://openusd.org/release/index.html> (USDZ: <https://openusd.org/release/spec_usdz.html>;
|
||||
//! textures: <https://openusd.org/release/spec_usdpreviewsurface.html>), OBJ and MTL
|
||||
//! <https://www.loc.gov/preservation/digital/formats/fdd/fdd000508.shtml>.
|
||||
|
||||
use std::fmt::Write as _;
|
||||
use std::sync::Arc;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_render::effects::SolidMesh;
|
||||
use vectorcraft_doc::color::{Color, Paint};
|
||||
use vectorcraft_doc::{Appearance, Document, Node, NodeId};
|
||||
use vectorcraft_geom::{Affine, Rect};
|
||||
use vectorcraft_render::effects::{MeshGraphics, SolidMesh};
|
||||
|
||||
/// The formats a 3D asset exports to, as `assets.set3DFormat` names them: USDA first, the default.
|
||||
pub const FORMATS_3D: [&str; 4] = ["usda", "usdz", "gltf", "obj"];
|
||||
@@ -23,6 +34,12 @@ pub const FORMATS_3D: [&str; 4] = ["usda", "usdz", "gltf", "obj"];
|
||||
pub const DEFAULT_FORMAT_3D: &str = "usda";
|
||||
/// The meters in a point (1/72 inch).
|
||||
const METERS_PER_POINT: f64 = 0.0254 / 72.0;
|
||||
/// The pixels along the longer side of a face's texture, unless `assets.export3D` is given another
|
||||
/// size, and the sizes it takes.
|
||||
pub(crate) const TEXTURE_SIZE: u32 = 1024;
|
||||
pub(crate) const TEXTURE_SIZES: (u32, u32) = (128, 4096);
|
||||
/// The most texture pixels one export draws, all its assets together.
|
||||
pub(crate) const MAX_TEXTURE_PIXELS: u64 = 4 * 4096 * 4096;
|
||||
|
||||
/// The label of `format` for menus: `USDA`, `USDZ`, `glTF`, `OBJ`.
|
||||
pub fn format_3d_label(format: &str) -> &'static str {
|
||||
@@ -40,14 +57,44 @@ fn obj_stem(stem: &str) -> String {
|
||||
stem.chars().map(|c| if c.is_whitespace() || c == '#' { '_' } else { c }).collect()
|
||||
}
|
||||
|
||||
/// The names of the files [`mesh_files`] writes for `stem` in `format`.
|
||||
pub(crate) fn mesh_file_names(stem: &str, format: &str) -> Result<Vec<String>, String> {
|
||||
/// The name of texture `k` (from 0) of the object named `stem`: whitespace, `#` and `@` become `_`,
|
||||
/// so an MTL `map_Kd` line and a USD asset path name it as one word.
|
||||
fn texture_name(stem: &str, k: usize) -> String {
|
||||
format!("{}-texture-{}.png", texture_stem(stem), k + 1)
|
||||
}
|
||||
|
||||
/// The name of the opacity map of texture `k` (from 0) of the object named `stem`, as
|
||||
/// [`texture_name`] names the texture.
|
||||
fn opacity_name(stem: &str, k: usize) -> String {
|
||||
format!("{}-texture-{}-opacity.png", texture_stem(stem), k + 1)
|
||||
}
|
||||
|
||||
/// `stem` with whitespace, `#` and `@` turned into `_`, for the names of its textures.
|
||||
fn texture_stem(stem: &str) -> String {
|
||||
stem.chars().map(|c| if c.is_whitespace() || c == '#' || c == '@' { '_' } else { c }).collect()
|
||||
}
|
||||
|
||||
/// The names of the files [`mesh_files`] writes for `stem` in `format` with the textures `images`
|
||||
/// ([`image_maps`]: for each, whether it has an opacity map): OBJ and USDA name a PNG file for each
|
||||
/// texture after them, and OBJ also one for each opacity map, after its texture; glTF and USDZ hold
|
||||
/// theirs.
|
||||
pub(crate) fn mesh_file_names(stem: &str, format: &str, images: &[bool]) -> Result<Vec<String>, String> {
|
||||
let beside = |mut names: Vec<String>, stem: &str, maps: bool| {
|
||||
for (k, map) in images.iter().enumerate() {
|
||||
names.push(texture_name(stem, k));
|
||||
if maps && *map {
|
||||
names.push(opacity_name(stem, k));
|
||||
}
|
||||
}
|
||||
names
|
||||
};
|
||||
match format {
|
||||
"obj" => {
|
||||
let stem = obj_stem(stem);
|
||||
Ok(vec![format!("{stem}.obj"), format!("{stem}.mtl")])
|
||||
Ok(beside(vec![format!("{stem}.obj"), format!("{stem}.mtl")], &stem, true))
|
||||
}
|
||||
"gltf" | "usda" | "usdz" => Ok(vec![format!("{stem}.{format}")]),
|
||||
"usda" => Ok(beside(vec![format!("{stem}.usda")], stem, false)),
|
||||
"gltf" | "usdz" => Ok(vec![format!("{stem}.{format}")]),
|
||||
_ => {
|
||||
let key = "format";
|
||||
Err(format!("`{key}` must be one of {}", FORMATS_3D.join(", ")))
|
||||
@@ -55,35 +102,109 @@ pub(crate) fn mesh_file_names(stem: &str, format: &str) -> Result<Vec<String>, S
|
||||
}
|
||||
}
|
||||
|
||||
/// A picture painted on one part of a 3D object ([`SolidMesh`]): a PNG, and for each corner of the
|
||||
/// part's mesh where it falls on the picture (0 to 1 across from the left, 0 to 1 down from the
|
||||
/// top). `opacity` is a grayscale PNG of the picture's alpha when some of it is not opaque.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(crate) struct Texture {
|
||||
pub png: Arc<Vec<u8>>,
|
||||
pub opacity: Option<Arc<Vec<u8>>>,
|
||||
pub uv: Vec<[f64; 2]>,
|
||||
}
|
||||
|
||||
/// A distinct picture of a 3D object: the PNG and its opacity map.
|
||||
type Picture = (Arc<Vec<u8>>, Option<Arc<Vec<u8>>>);
|
||||
|
||||
/// The distinct pictures of `textures` in order of first use, and the index among them of each
|
||||
/// part's (`None` for a part without one).
|
||||
fn images(parts: usize, textures: &[Option<Texture>]) -> (Vec<Picture>, Vec<Option<usize>>) {
|
||||
let mut out: Vec<Picture> = vec![];
|
||||
let index = (0..parts)
|
||||
.map(|k| {
|
||||
let t = textures.get(k)?.as_ref()?;
|
||||
Some(out.iter().position(|(p, _)| Arc::ptr_eq(p, &t.png) || p == &t.png).unwrap_or_else(|| {
|
||||
out.push((t.png.clone(), t.opacity.clone()));
|
||||
out.len() - 1
|
||||
}))
|
||||
})
|
||||
.collect();
|
||||
(out, index)
|
||||
}
|
||||
|
||||
/// For each distinct picture of `textures`, whether it has an opacity map ([`mesh_file_names`]).
|
||||
pub(crate) fn image_maps(textures: &[Option<Texture>]) -> Vec<bool> {
|
||||
images(textures.len(), textures).0.iter().map(|(_, map)| map.is_some()).collect()
|
||||
}
|
||||
|
||||
/// The files of a 3D object named `stem` in `format` ([`FORMATS_3D`]): `(file name, bytes)`, the
|
||||
/// OBJ with its MTL after it.
|
||||
pub(crate) fn mesh_files(stem: &str, format: &str, parts: &[SolidMesh]) -> Result<Vec<(String, Vec<u8>)>, String> {
|
||||
let names = mesh_file_names(stem, format)?;
|
||||
let bytes = match format {
|
||||
/// OBJ with its MTL after it and the PNG files of `textures` last (an OBJ's opacity maps each after
|
||||
/// its texture). `textures` holds the picture of each part that has one, in the order of `parts`.
|
||||
pub(crate) fn mesh_files(stem: &str, format: &str, parts: &[SolidMesh], textures: &[Option<Texture>]) -> Result<Vec<(String, Vec<u8>)>, String> {
|
||||
let (images, image) = images(parts.len(), textures);
|
||||
let maps: Vec<bool> = images.iter().map(|(_, map)| map.is_some()).collect();
|
||||
let names = mesh_file_names(stem, format, &maps)?;
|
||||
let pictures: Vec<Arc<Vec<u8>>> = images.iter().map(|(p, _)| p.clone()).collect();
|
||||
let scene = Scene { parts, textures, image: &image, pictures: &pictures, maps: &maps };
|
||||
let pngs = || pictures.iter().map(|p| p.as_ref().clone());
|
||||
let bytes: Vec<Vec<u8>> = match format {
|
||||
"obj" => {
|
||||
let (obj, mtl) = obj(&obj_stem(stem), parts);
|
||||
vec![obj.into_bytes(), mtl.into_bytes()]
|
||||
let stem = obj_stem(stem);
|
||||
let (obj, mtl) = obj(&stem, &scene);
|
||||
let with_maps = images.iter().flat_map(|(p, map)| std::iter::once(p.as_ref().clone()).chain(map.as_ref().map(|m| m.as_ref().clone())));
|
||||
[obj.into_bytes(), mtl.into_bytes()].into_iter().chain(with_maps).collect()
|
||||
}
|
||||
"gltf" => vec![gltf(stem, &scene).into_bytes()],
|
||||
"usda" => std::iter::once(usda(stem, &scene).into_bytes()).chain(pngs()).collect(),
|
||||
_ => {
|
||||
let mut members = vec![(format!("{stem}.usda"), usda(stem, &scene).into_bytes())];
|
||||
members.extend(pngs().enumerate().map(|(k, png)| (texture_name(stem, k), png)));
|
||||
vec![super::zip::store_aligned(&members, 64)?]
|
||||
}
|
||||
"gltf" => vec![gltf(stem, parts).into_bytes()],
|
||||
"usda" => vec![usda(stem, parts).into_bytes()],
|
||||
_ => vec![super::zip::store_aligned(&[(format!("{stem}.usda"), usda(stem, parts).into_bytes())], 64)?],
|
||||
};
|
||||
Ok(names.into_iter().zip(bytes).collect())
|
||||
}
|
||||
|
||||
/// The distinct colors of `parts` in order, and each part's index among them.
|
||||
fn materials(parts: &[SolidMesh]) -> (Vec<[f32; 4]>, Vec<usize>) {
|
||||
let mut colors: Vec<[f32; 4]> = vec![];
|
||||
let index = parts
|
||||
/// The parts of an object with their pictures: `image` is each part's index among `pictures`, and
|
||||
/// `maps` says for each picture whether it has an opacity map.
|
||||
struct Scene<'a> {
|
||||
parts: &'a [SolidMesh],
|
||||
textures: &'a [Option<Texture>],
|
||||
image: &'a [Option<usize>],
|
||||
pictures: &'a [Arc<Vec<u8>>],
|
||||
maps: &'a [bool],
|
||||
}
|
||||
|
||||
impl Scene<'_> {
|
||||
/// Part `k`'s texture coordinates and picture, when it has a picture.
|
||||
fn texture(&self, k: usize) -> Option<(&[[f64; 2]], usize)> {
|
||||
let t = self.textures.get(k)?.as_ref()?;
|
||||
Some((t.uv.as_slice(), (*self.image.get(k)?)?))
|
||||
}
|
||||
}
|
||||
|
||||
/// A material: a color, with a picture that replaces its red, green and blue.
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
struct Material {
|
||||
color: [f32; 4],
|
||||
image: Option<usize>,
|
||||
}
|
||||
|
||||
/// The distinct materials of `scene`'s parts in order, and each part's index among them.
|
||||
fn materials(scene: &Scene) -> (Vec<Material>, Vec<usize>) {
|
||||
let mut out: Vec<Material> = vec![];
|
||||
let index = scene
|
||||
.parts
|
||||
.iter()
|
||||
.map(|p| {
|
||||
colors.iter().position(|c| *c == p.color).unwrap_or_else(|| {
|
||||
colors.push(p.color);
|
||||
colors.len() - 1
|
||||
.enumerate()
|
||||
.map(|(k, p)| {
|
||||
let m = Material { color: p.color, image: scene.texture(k).map(|(_, i)| i) };
|
||||
out.iter().position(|c| *c == m).unwrap_or_else(|| {
|
||||
out.push(m);
|
||||
out.len() - 1
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
(colors, index)
|
||||
(out, index)
|
||||
}
|
||||
|
||||
/// An sRGB channel (0..1) as linear light.
|
||||
@@ -96,8 +217,9 @@ fn num(v: f64) -> String {
|
||||
format!("{v}")
|
||||
}
|
||||
|
||||
fn obj(stem: &str, parts: &[SolidMesh]) -> (String, String) {
|
||||
let (colors, material) = materials(parts);
|
||||
fn obj(stem: &str, scene: &Scene) -> (String, String) {
|
||||
let parts = scene.parts;
|
||||
let (materials, material) = materials(scene);
|
||||
let mut o = String::new();
|
||||
let _ = writeln!(o, "mtllib {stem}.mtl");
|
||||
let _ = writeln!(o, "o {stem}");
|
||||
@@ -106,33 +228,64 @@ fn obj(stem: &str, parts: &[SolidMesh]) -> (String, String) {
|
||||
let _ = writeln!(o, "v {} {} {}", num(v[0]), num(v[1]), num(v[2]));
|
||||
}
|
||||
}
|
||||
// OBJ's texture coordinates run up from the picture's bottom.
|
||||
for k in 0..parts.len() {
|
||||
for uv in scene.texture(k).map(|(uv, _)| uv).unwrap_or_default() {
|
||||
let _ = writeln!(o, "vt {} {}", num(uv[0]), num(1.0 - uv[1]));
|
||||
}
|
||||
}
|
||||
for p in parts {
|
||||
for n in &p.mesh.normals {
|
||||
let _ = writeln!(o, "vn {} {} {}", num(n[0]), num(n[1]), num(n[2]));
|
||||
}
|
||||
}
|
||||
let mut base = 1usize;
|
||||
let (mut base, mut uv_base) = (1usize, 1usize);
|
||||
for (k, p) in parts.iter().enumerate() {
|
||||
let _ = writeln!(o, "g Solid_{}", k + 1);
|
||||
let _ = writeln!(o, "usemtl Material_{}", material.get(k).copied().unwrap_or(0) + 1);
|
||||
let textured = scene.texture(k).filter(|(uv, _)| uv.len() == p.mesh.positions.len()).is_some();
|
||||
for t in &p.mesh.triangles {
|
||||
let [a, b, c] = t.map(|i| i as usize + base);
|
||||
let _ = writeln!(o, "f {a}//{a} {b}//{b} {c}//{c}");
|
||||
if textured {
|
||||
let [a, b, c] = t.map(|i| i as usize);
|
||||
let corner = |i: usize| format!("{}/{}/{}", i + base, i + uv_base, i + base);
|
||||
let _ = writeln!(o, "f {} {} {}", corner(a), corner(b), corner(c));
|
||||
} else {
|
||||
let [a, b, c] = t.map(|i| i as usize + base);
|
||||
let _ = writeln!(o, "f {a}//{a} {b}//{b} {c}//{c}");
|
||||
}
|
||||
}
|
||||
base += p.mesh.positions.len();
|
||||
uv_base += scene.texture(k).map_or(0, |(uv, _)| uv.len());
|
||||
}
|
||||
let mut m = String::new();
|
||||
for (k, c) in colors.iter().enumerate() {
|
||||
for (k, mat) in materials.iter().enumerate() {
|
||||
let c = mat.color;
|
||||
let _ = writeln!(m, "newmtl Material_{}", k + 1);
|
||||
let _ = writeln!(m, "Kd {} {} {}", num(f64::from(c[0])), num(f64::from(c[1])), num(f64::from(c[2])));
|
||||
let _ = writeln!(m, "d {}", num(f64::from(c[3])));
|
||||
match mat.image {
|
||||
// The picture holds the color; Kd multiplies it.
|
||||
Some(_) => {
|
||||
let _ = writeln!(m, "Kd 1 1 1");
|
||||
}
|
||||
None => {
|
||||
let _ = writeln!(m, "Kd {} {} {}", num(f64::from(c[0])), num(f64::from(c[1])), num(f64::from(c[2])));
|
||||
}
|
||||
}
|
||||
// A picture's opacity map holds the opacity, as gray levels.
|
||||
let _ = writeln!(m, "d {}", if mat.image.is_some() { "1".to_string() } else { num(f64::from(c[3])) });
|
||||
let _ = writeln!(m, "illum 1");
|
||||
if let Some(i) = mat.image {
|
||||
let _ = writeln!(m, "map_Kd -clamp on {}", texture_name(stem, i));
|
||||
if scene.maps.get(i).copied().unwrap_or(false) {
|
||||
let _ = writeln!(m, "map_d -clamp on {}", opacity_name(stem, i));
|
||||
}
|
||||
}
|
||||
}
|
||||
(o, m)
|
||||
}
|
||||
|
||||
fn gltf(stem: &str, parts: &[SolidMesh]) -> String {
|
||||
let (colors, material) = materials(parts);
|
||||
fn gltf(stem: &str, scene: &Scene) -> String {
|
||||
let parts = scene.parts;
|
||||
let (materials, material) = materials(scene);
|
||||
let mut buffer: Vec<u8> = vec![];
|
||||
let (mut views, mut accessors, mut primitives) = (vec![], vec![], vec![]);
|
||||
let mut view = |buffer: &mut Vec<u8>, bytes: Vec<u8>, target: u32| -> usize {
|
||||
@@ -154,16 +307,25 @@ fn gltf(stem: &str, parts: &[SolidMesh]) -> String {
|
||||
}));
|
||||
accessors.push(json!({ "bufferView": normals, "componentType": 5126, "count": count, "type": "VEC3" }));
|
||||
accessors.push(json!({ "bufferView": indices, "componentType": 5125, "count": p.mesh.triangles.len() * 3, "type": "SCALAR" }));
|
||||
primitives.push(json!({
|
||||
let mut primitive = json!({
|
||||
"attributes": { "POSITION": at, "NORMAL": at + 1 },
|
||||
"indices": at + 2,
|
||||
"material": material.get(k).copied().unwrap_or(0),
|
||||
}));
|
||||
});
|
||||
// glTF's texture coordinates run down from the picture's top, as the picture's own do.
|
||||
if let Some((uv, _)) = scene.texture(k).filter(|(uv, _)| uv.len() == count) {
|
||||
let bytes = uv.iter().flatten().flat_map(|x| (*x as f32).to_le_bytes()).collect();
|
||||
let coords = view(&mut buffer, bytes, 34962);
|
||||
primitive["attributes"]["TEXCOORD_0"] = json!(accessors.len());
|
||||
accessors.push(json!({ "bufferView": coords, "componentType": 5126, "count": count, "type": "VEC2" }));
|
||||
}
|
||||
primitives.push(primitive);
|
||||
}
|
||||
let materials: Vec<Value> = colors
|
||||
let materials: Vec<Value> = materials
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(k, c)| {
|
||||
.map(|(k, mat)| {
|
||||
let c = mat.color;
|
||||
let mut m = json!({
|
||||
"name": format!("Material_{}", k + 1),
|
||||
"pbrMetallicRoughness": {
|
||||
@@ -173,13 +335,18 @@ fn gltf(stem: &str, parts: &[SolidMesh]) -> String {
|
||||
},
|
||||
"doubleSided": true,
|
||||
});
|
||||
if let Some(i) = mat.image {
|
||||
// The picture holds the color and the opacity; the factor multiplies them.
|
||||
m["pbrMetallicRoughness"]["baseColorFactor"] = json!([1.0, 1.0, 1.0, 1.0]);
|
||||
m["pbrMetallicRoughness"]["baseColorTexture"] = json!({ "index": i });
|
||||
}
|
||||
if c[3] < 1.0 {
|
||||
m["alphaMode"] = json!("BLEND");
|
||||
}
|
||||
m
|
||||
})
|
||||
.collect();
|
||||
let doc = json!({
|
||||
let mut doc = json!({
|
||||
"asset": { "version": "2.0", "generator": "VectorCraft" },
|
||||
"scene": 0,
|
||||
"scenes": [{ "nodes": [0] }],
|
||||
@@ -193,6 +360,14 @@ fn gltf(stem: &str, parts: &[SolidMesh]) -> String {
|
||||
"bufferViews": views,
|
||||
"accessors": accessors,
|
||||
});
|
||||
if !scene.pictures.is_empty() {
|
||||
// Linear filtering, mipmaps, and coordinates held at the picture's edge.
|
||||
doc["samplers"] = json!([{ "magFilter": 9729, "minFilter": 9987, "wrapS": 33071, "wrapT": 33071 }]);
|
||||
doc["textures"] = Value::Array((0..scene.pictures.len()).map(|i| json!({ "sampler": 0, "source": i })).collect());
|
||||
doc["images"] = Value::Array(
|
||||
scene.pictures.iter().map(|p| json!({ "uri": format!("data:image/png;base64,{}", vectorcraft_format::base64_encode(p)) })).collect(),
|
||||
);
|
||||
}
|
||||
serde_json::to_string_pretty(&doc).unwrap_or_default()
|
||||
}
|
||||
|
||||
@@ -205,8 +380,9 @@ fn prim_name(name: &str) -> String {
|
||||
out
|
||||
}
|
||||
|
||||
fn usda(stem: &str, parts: &[SolidMesh]) -> String {
|
||||
let (colors, material) = materials(parts);
|
||||
fn usda(stem: &str, scene: &Scene) -> String {
|
||||
let parts = scene.parts;
|
||||
let (materials, material) = materials(scene);
|
||||
let root = prim_name(stem);
|
||||
let triple = |v: [f64; 3]| format!("({}, {}, {})", num(v[0]), num(v[1]), num(v[2]));
|
||||
let list = |items: Vec<String>| items.join(", ");
|
||||
@@ -238,23 +414,178 @@ fn usda(stem: &str, parts: &[SolidMesh]) -> String {
|
||||
linear(c[2])
|
||||
);
|
||||
let _ = writeln!(u, " float[] primvars:displayOpacity = [{}] (\n interpolation = \"constant\"\n )", c[3]);
|
||||
// USD's texture coordinates run up from the picture's bottom.
|
||||
if let Some((uv, _)) = scene.texture(k).filter(|(uv, _)| uv.len() == p.mesh.positions.len()) {
|
||||
let st = list(uv.iter().map(|t| format!("({}, {})", num(t[0]), num(1.0 - t[1]))).collect());
|
||||
let _ = writeln!(u, " texCoord2f[] primvars:st = [{st}] (\n interpolation = \"vertex\"\n )");
|
||||
}
|
||||
let _ = writeln!(u, " uniform token subdivisionScheme = \"none\"\n }}\n");
|
||||
}
|
||||
let _ = writeln!(u, " def Scope \"Materials\"\n {{");
|
||||
for (k, c) in colors.iter().enumerate() {
|
||||
let m = k + 1;
|
||||
for (k, mat) in materials.iter().enumerate() {
|
||||
let (m, c) = (k + 1, mat.color);
|
||||
let at = format!("/{root}/Materials/Material_{m}");
|
||||
let _ = writeln!(u, " def Material \"Material_{m}\"\n {{");
|
||||
let _ = writeln!(u, " token outputs:surface.connect = </{root}/Materials/Material_{m}/Surface.outputs:surface>\n");
|
||||
let _ = writeln!(u, " token outputs:surface.connect = <{at}/Surface.outputs:surface>\n");
|
||||
let _ = writeln!(u, " def Shader \"Surface\"\n {{");
|
||||
let _ = writeln!(u, " uniform token info:id = \"UsdPreviewSurface\"");
|
||||
let _ = writeln!(u, " color3f inputs:diffuseColor = ({}, {}, {})", linear(c[0]), linear(c[1]), linear(c[2]));
|
||||
let _ = writeln!(u, " float inputs:opacity = {}", c[3]);
|
||||
match mat.image {
|
||||
// The picture holds the color, and the opacity when the face is not opaque.
|
||||
Some(_) => {
|
||||
let _ = writeln!(u, " color3f inputs:diffuseColor.connect = <{at}/Texture.outputs:rgb>");
|
||||
if c[3] < 1.0 {
|
||||
let _ = writeln!(u, " float inputs:opacity.connect = <{at}/Texture.outputs:a>");
|
||||
} else {
|
||||
let _ = writeln!(u, " float inputs:opacity = 1");
|
||||
}
|
||||
}
|
||||
None => {
|
||||
let _ = writeln!(u, " color3f inputs:diffuseColor = ({}, {}, {})", linear(c[0]), linear(c[1]), linear(c[2]));
|
||||
let _ = writeln!(u, " float inputs:opacity = {}", c[3]);
|
||||
}
|
||||
}
|
||||
let _ = writeln!(u, " float inputs:roughness = 1");
|
||||
let _ = writeln!(u, " token outputs:surface\n }}\n }}");
|
||||
let _ = writeln!(u, " token outputs:surface\n }}");
|
||||
if let Some(i) = mat.image {
|
||||
let _ = writeln!(u, "\n def Shader \"Texture\"\n {{");
|
||||
let _ = writeln!(u, " uniform token info:id = \"UsdUVTexture\"");
|
||||
let _ = writeln!(u, " asset inputs:file = @{}@", texture_name(stem, i));
|
||||
let _ = writeln!(u, " float2 inputs:st.connect = <{at}/Coordinates.outputs:result>");
|
||||
let _ = writeln!(u, " token inputs:sourceColorSpace = \"sRGB\"");
|
||||
let _ = writeln!(u, " token inputs:wrapS = \"clamp\"");
|
||||
let _ = writeln!(u, " token inputs:wrapT = \"clamp\"");
|
||||
let _ = writeln!(u, " float3 outputs:rgb");
|
||||
if c[3] < 1.0 {
|
||||
let _ = writeln!(u, " float outputs:a");
|
||||
}
|
||||
let _ = writeln!(u, " }}");
|
||||
let _ = writeln!(u, "\n def Shader \"Coordinates\"\n {{");
|
||||
let _ = writeln!(u, " uniform token info:id = \"UsdPrimvarReader_float2\"");
|
||||
let _ = writeln!(u, " string inputs:varname = \"st\"");
|
||||
let _ = writeln!(u, " float2 outputs:result\n }}");
|
||||
}
|
||||
let _ = writeln!(u, " }}");
|
||||
}
|
||||
let _ = writeln!(u, " }}\n}}");
|
||||
u
|
||||
}
|
||||
|
||||
/// The pictures of the graphics on `parts` ([`SolidMesh::graphics`]), one for each part in order
|
||||
/// (`None` for a part without graphics, or whose graphics draw nothing): the part's color with its
|
||||
/// graphics drawn over it, flat and unshaded ([`vectorcraft_render::effects::mesh_graphics_art`]),
|
||||
/// over the bounds of the art points of its corners, `size` pixels along the longer side. Parts with
|
||||
/// the same color, face, graphics and bounds share one picture. `pixels` counts the pixels drawn so
|
||||
/// far, and every call of one export shares it: an error when it passes [`MAX_TEXTURE_PIXELS`].
|
||||
pub(crate) fn textures(doc: &Document, parts: &[SolidMesh], size: u32, pixels: &mut u64) -> Result<Vec<Option<Texture>>, String> {
|
||||
let mut renderer: Option<vectorcraft_render::Renderer> = None;
|
||||
// Each picture drawn: the part it was drawn for, its bounds, and the PNG with its opacity map
|
||||
// (`None`: nothing drawn).
|
||||
let mut drawn: Vec<Drawn> = vec![];
|
||||
let mut out = vec![];
|
||||
for part in parts {
|
||||
let Some(g) = &part.graphics else {
|
||||
out.push(None);
|
||||
continue;
|
||||
};
|
||||
let Some(frame) = texture_frame(g) else {
|
||||
out.push(None);
|
||||
continue;
|
||||
};
|
||||
let scale = f64::from(size) / frame.width().max(frame.height());
|
||||
let fit = |side: f64| ((side * scale).ceil() as u32).clamp(1, size);
|
||||
let (w, h) = (fit(frame.width()), fit(frame.height()));
|
||||
let same = |(p, r, _): &&Drawn| p.color == part.color && *r == frame && p.graphics.as_ref().is_some_and(|o| same_graphics(o, g));
|
||||
let png = match drawn.iter().find(same) {
|
||||
Some((_, _, png)) => png.clone(),
|
||||
None => {
|
||||
let png = match vectorcraft_render::effects::mesh_graphics_art(doc, NodeId(0), g)? {
|
||||
None => None,
|
||||
Some(art) => {
|
||||
*pixels = pixels.saturating_add(u64::from(w) * u64::from(h));
|
||||
if *pixels > MAX_TEXTURE_PIXELS {
|
||||
return Err(format!(
|
||||
"the graphics need more than {MAX_TEXTURE_PIXELS} pixels of textures: lower textureSize (now {size})"
|
||||
));
|
||||
}
|
||||
let renderer = renderer.get_or_insert_with(vectorcraft_render::Renderer::new);
|
||||
Some(picture(doc, renderer, (part.color, g.opacity, g.object), art, (frame, scale), (w, h))?)
|
||||
}
|
||||
};
|
||||
drawn.push((part, frame, png.clone()));
|
||||
png
|
||||
}
|
||||
};
|
||||
out.push(png.map(|(png, opacity)| {
|
||||
let uv = g.art.iter().map(|p| [(p.x - frame.x0) * scale / f64::from(w), (p.y - frame.y0) * scale / f64::from(h)]).collect();
|
||||
Texture { png, opacity, uv }
|
||||
}));
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// Does [`textures`] draw a picture for one of `parts`: a part with graphics whose corners span an
|
||||
/// area and whose graphics draw something? Nothing is rendered.
|
||||
pub fn draws_textures(doc: &Document, parts: &[SolidMesh]) -> bool {
|
||||
parts.iter().any(|p| {
|
||||
p.graphics
|
||||
.as_ref()
|
||||
.is_some_and(|g| texture_frame(g).is_some() && matches!(vectorcraft_render::effects::mesh_graphics_art(doc, NodeId(0), g), Ok(Some(_))))
|
||||
})
|
||||
}
|
||||
|
||||
/// The part of the art's plane a picture of `g` covers: the bounds of its corners' art points, when
|
||||
/// they span an area.
|
||||
fn texture_frame(g: &MeshGraphics) -> Option<Rect> {
|
||||
g.art_bounds().filter(|r| r.width() > 1e-9 && r.height() > 1e-9 && r.width().is_finite() && r.height().is_finite())
|
||||
}
|
||||
|
||||
/// A picture [`textures`] drew: the part, the bounds and the PNG with its opacity map.
|
||||
type Drawn<'a> = (&'a SolidMesh, Rect, Option<Picture>);
|
||||
|
||||
/// Do `a` and `b` draw the same graphics on their face?
|
||||
fn same_graphics(a: &MeshGraphics, b: &MeshGraphics) -> bool {
|
||||
a.face == b.face && a.center == b.center && a.graphics == b.graphics && a.opacity == b.opacity && a.object == b.object
|
||||
}
|
||||
|
||||
/// `art` drawn over `color` as a PNG of `w` × `h` pixels whose top left is `frame`'s top left, at
|
||||
/// `scale` pixels a point, with a grayscale PNG of its alpha when some of it is not opaque. As on
|
||||
/// the canvas, the art is drawn at `face` (the opacity of the face's fill or stroke), the color at
|
||||
/// its own opacity without `object`'s, and `object` (the object's opacity) applies to the whole
|
||||
/// picture.
|
||||
fn picture(
|
||||
doc: &Document,
|
||||
renderer: &mut vectorcraft_render::Renderer,
|
||||
(color, face, object): ([f32; 4], f32, f32),
|
||||
mut art: Node,
|
||||
(frame, scale): (Rect, f64),
|
||||
(w, h): (u32, u32),
|
||||
) -> Result<Picture, String> {
|
||||
// The color reaches two pixels past the frame, so the picture's edge pixels are covered.
|
||||
let reach = 2.0 / scale;
|
||||
let back = Rect::new(frame.x0 - reach, frame.y0 - reach, frame.x0 + f64::from(w) / scale + reach, frame.y0 + f64::from(h) / scale + reach);
|
||||
let fill = Paint::solid(Color::rgb(color[0], color[1], color[2]));
|
||||
let mut ground = Node::path(NodeId(0), vectorcraft_geom::shapes::rectangle(back), Appearance::basic(fill, Paint::None, 0.0));
|
||||
let unit = |v: f32| if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 };
|
||||
let object = unit(object);
|
||||
ground.opacity = if object > 0.0 { unit(color[3] / object) } else { 0.0 };
|
||||
art.opacity *= unit(face);
|
||||
let mut group = Node::group(NodeId(0), vec![Arc::new(ground), Arc::new(art)]);
|
||||
group.opacity = object;
|
||||
let group = Arc::new(group);
|
||||
let (pw, ph) = (u16::try_from(w).map_err(|_| "texture too large")?, u16::try_from(h).map_err(|_| "texture too large")?);
|
||||
let view = Affine::scale(scale) * Affine::translate((-frame.x0, -frame.y0));
|
||||
let drawn = renderer.render_node(doc, &group, pw, ph, view).ok_or_else(|| "the graphics could not be drawn".to_string())?;
|
||||
let alpha: Vec<u8> = drawn.pixels.iter().skip(3).step_by(4).copied().collect();
|
||||
let opacity = if alpha.iter().all(|a| *a == 255) {
|
||||
None
|
||||
} else {
|
||||
let gray = image::GrayImage::from_raw(w, h, alpha).ok_or("the texture's opacity could not be drawn")?;
|
||||
let mut png = vec![];
|
||||
gray.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).map_err(|e| format!("PNG encoding failed: {e}"))?;
|
||||
Some(Arc::new(png))
|
||||
};
|
||||
Ok((Arc::new(drawn.to_png()?), opacity))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
@@ -7,7 +7,7 @@ use super::*;
|
||||
fn square(color: [f32; 4]) -> SolidMesh {
|
||||
let [a, b, c, d] = [[-5.0, -5.0, 0.0], [5.0, -5.0, 0.0], [5.0, 5.0, 0.0], [-5.0, 5.0, 0.0]];
|
||||
let mesh = Mesh { positions: vec![a, b, c, a, c, d], normals: vec![[0.0, 0.0, 1.0]; 6], triangles: vec![[0, 1, 2], [3, 4, 5]] };
|
||||
SolidMesh { mesh, color }
|
||||
SolidMesh::plain(mesh, color)
|
||||
}
|
||||
|
||||
const RED: [f32; 4] = [1.0, 0.0, 0.0, 1.0];
|
||||
@@ -18,9 +18,14 @@ fn text(files: &[(String, Vec<u8>)], name: &str) -> String {
|
||||
String::from_utf8(bytes.clone()).unwrap()
|
||||
}
|
||||
|
||||
/// [`mesh_files`] without textures.
|
||||
fn plain_files(stem: &str, format: &str, parts: &[SolidMesh]) -> Result<Vec<(String, Vec<u8>)>, String> {
|
||||
mesh_files(stem, format, parts, &[])
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn obj_numbers_corners_across_solids_and_names_its_materials() {
|
||||
let files = mesh_files("Box", "obj", &[square(RED), square(BLUE), square(RED)]).unwrap();
|
||||
let files = plain_files("Box", "obj", &[square(RED), square(BLUE), square(RED)]).unwrap();
|
||||
assert_eq!(files.iter().map(|(n, _)| n.as_str()).collect::<Vec<_>>(), ["Box.obj", "Box.mtl"]);
|
||||
let obj = text(&files, "Box.obj");
|
||||
assert!(obj.starts_with("mtllib Box.mtl\no Box\n"));
|
||||
@@ -36,7 +41,7 @@ fn obj_numbers_corners_across_solids_and_names_its_materials() {
|
||||
|
||||
#[test]
|
||||
fn gltf_holds_its_buffer_and_every_accessor_fits_it() {
|
||||
let files = mesh_files("Box", "gltf", &[square(RED), square(BLUE)]).unwrap();
|
||||
let files = plain_files("Box", "gltf", &[square(RED), square(BLUE)]).unwrap();
|
||||
let g: Value = serde_json::from_str(&text(&files, "Box.gltf")).unwrap();
|
||||
assert_eq!(g["asset"]["version"], "2.0");
|
||||
let uri = g["buffers"][0]["uri"].as_str().unwrap();
|
||||
@@ -59,11 +64,13 @@ fn gltf_holds_its_buffer_and_every_accessor_fits_it() {
|
||||
assert_eq!(g["materials"][1]["alphaMode"], "BLEND");
|
||||
assert!(g["materials"][0].get("alphaMode").is_none());
|
||||
assert_eq!(g["materials"][0]["doubleSided"], true);
|
||||
// Without graphics there are no textures.
|
||||
assert!(g.get("images").is_none() && g.get("textures").is_none() && prims[0]["attributes"].get("TEXCOORD_0").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn usda_is_y_up_in_points_with_a_material_for_each_color() {
|
||||
let files = mesh_files("My Box", "usda", &[square(RED), square([0.5, 0.5, 0.5, 1.0])]).unwrap();
|
||||
let files = plain_files("My Box", "usda", &[square(RED), square([0.5, 0.5, 0.5, 1.0])]).unwrap();
|
||||
let u = text(&files, "My Box.usda");
|
||||
assert!(u.starts_with("#usda 1.0\n"));
|
||||
assert!(u.contains("defaultPrim = \"My_Box\"") && u.contains("upAxis = \"Y\"") && u.contains("def Xform \"My_Box\""), "{u}");
|
||||
@@ -75,11 +82,12 @@ fn usda_is_y_up_in_points_with_a_material_for_each_color() {
|
||||
// sRGB 0.5 is about 0.214 linear.
|
||||
assert!(u.contains("color3f inputs:diffuseColor = (0.21404"), "{u}");
|
||||
assert_eq!(u.matches('{').count(), u.matches('}').count());
|
||||
assert!(!u.contains("primvars:st") && !u.contains("UsdUVTexture"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn usdz_stores_the_layer_uncompressed_on_a_64_byte_boundary() {
|
||||
let files = mesh_files("Box", "usdz", &[square(RED)]).unwrap();
|
||||
let files = plain_files("Box", "usdz", &[square(RED)]).unwrap();
|
||||
let (name, zip) = &files[0];
|
||||
assert_eq!(name, "Box.usdz");
|
||||
// The local header: 30 bytes, the name, then the extra field.
|
||||
@@ -88,7 +96,7 @@ fn usdz_stores_the_layer_uncompressed_on_a_64_byte_boundary() {
|
||||
assert_eq!(u16_at(8), 0, "stored, not deflated");
|
||||
let start = 30 + u16_at(26) + u16_at(28);
|
||||
assert_eq!(start % 64, 0);
|
||||
let layer = mesh_files("Box", "usda", &[square(RED)]).unwrap().remove(0).1;
|
||||
let layer = plain_files("Box", "usda", &[square(RED)]).unwrap().remove(0).1;
|
||||
assert_eq!(&zip[start..start + layer.len()], layer.as_slice());
|
||||
let archive = super::super::zip::Archive::open(zip, 8).unwrap();
|
||||
assert_eq!(archive.read("Box.usda", usize::MAX).unwrap(), Some(layer));
|
||||
@@ -96,11 +104,11 @@ fn usdz_stores_the_layer_uncompressed_on_a_64_byte_boundary() {
|
||||
|
||||
#[test]
|
||||
fn an_obj_names_its_mtl_file_without_spaces_or_comment_marks() {
|
||||
let files = mesh_files("Box #1", "obj", &[square(RED)]).unwrap();
|
||||
let files = plain_files("Box #1", "obj", &[square(RED)]).unwrap();
|
||||
assert_eq!(files.iter().map(|(n, _)| n.as_str()).collect::<Vec<_>>(), ["Box__1.obj", "Box__1.mtl"]);
|
||||
assert!(text(&files, "Box__1.obj").starts_with("mtllib Box__1.mtl\n"));
|
||||
assert_eq!(mesh_file_names("Box #1", "obj").unwrap(), ["Box__1.obj", "Box__1.mtl"]);
|
||||
assert_eq!(mesh_file_names("Box #1", "usda").unwrap(), ["Box #1.usda"]);
|
||||
assert_eq!(mesh_file_names("Box #1", "obj", &[]).unwrap(), ["Box__1.obj", "Box__1.mtl"]);
|
||||
assert_eq!(mesh_file_names("Box #1", "usda", &[]).unwrap(), ["Box #1.usda"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -108,17 +116,17 @@ fn obj_and_usda_keep_coordinates_a_32_bit_float_would_merge() {
|
||||
let mut part = square(RED);
|
||||
part.mesh.positions[0] = [20_000_000.0, 0.0, 0.0];
|
||||
part.mesh.positions[1] = [20_000_001.0, 0.0, 0.0];
|
||||
let obj = text(&mesh_files("Box", "obj", std::slice::from_ref(&part)).unwrap(), "Box.obj");
|
||||
let obj = text(&plain_files("Box", "obj", std::slice::from_ref(&part)).unwrap(), "Box.obj");
|
||||
assert!(obj.contains("v 20000000 0 0\nv 20000001 0 0\n"), "{obj}");
|
||||
let usda = text(&mesh_files("Box", "usda", &[part]).unwrap(), "Box.usda");
|
||||
let usda = text(&plain_files("Box", "usda", &[part]).unwrap(), "Box.usda");
|
||||
assert!(usda.contains("(20000001, 0, 0)"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unknown_format_is_refused() {
|
||||
assert!(mesh_files("Box", "fbx", &[square(RED)]).is_err());
|
||||
assert!(mesh_file_names("Box", "").is_err());
|
||||
assert_eq!(mesh_file_names("Box", "obj").unwrap(), ["Box.obj", "Box.mtl"]);
|
||||
assert!(plain_files("Box", "fbx", &[square(RED)]).is_err());
|
||||
assert!(mesh_file_names("Box", "", &[]).is_err());
|
||||
assert_eq!(mesh_file_names("Box", "obj", &[]).unwrap(), ["Box.obj", "Box.mtl"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -128,3 +136,114 @@ fn prim_names_are_usd_identifiers() {
|
||||
assert_eq!(prim_name(""), "_");
|
||||
assert_eq!(prim_name("é/x"), "__x");
|
||||
}
|
||||
|
||||
/// A red square, then a blue one whose corners show picture `png` (u to the right, v down).
|
||||
fn textured(png: &[u8]) -> (Vec<SolidMesh>, Vec<Option<Texture>>) {
|
||||
let uv = vec![[0.0, 1.0], [1.0, 1.0], [1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [0.0, 0.0]];
|
||||
let texture = Texture { png: Arc::new(png.to_vec()), opacity: None, uv };
|
||||
(vec![square(RED), square(BLUE)], vec![None, Some(texture)])
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn each_format_carries_a_textured_part_with_its_coordinates_and_picture() {
|
||||
let png = b"\x89PNG picture".to_vec();
|
||||
let (parts, pictures) = textured(&png);
|
||||
// OBJ: vt runs up from the picture's bottom, the textured faces name it, and map_Kd the PNG
|
||||
// written beside it, with its name in one word.
|
||||
let files = mesh_files("My Box", "obj", &parts, &pictures).unwrap();
|
||||
assert_eq!(files.iter().map(|(n, _)| n.as_str()).collect::<Vec<_>>(), ["My_Box.obj", "My_Box.mtl", "My_Box-texture-1.png"]);
|
||||
assert_eq!(files[2].1, png);
|
||||
let obj = text(&files, "My_Box.obj");
|
||||
assert_eq!(obj.lines().filter(|l| l.starts_with("vt ")).collect::<Vec<_>>(), ["vt 0 0", "vt 1 0", "vt 1 1", "vt 0 0", "vt 1 1", "vt 0 1"]);
|
||||
assert_eq!(obj.lines().rfind(|l| l.starts_with("f ")), Some("f 10/4/10 11/5/11 12/6/12"));
|
||||
assert!(obj.contains("f 1//1 2//2 3//3"), "the plain part keeps no texture coordinates");
|
||||
let mtl = text(&files, "My_Box.mtl");
|
||||
assert!(mtl.contains("newmtl Material_2\nKd 1 1 1\nd 1\nillum 1\nmap_Kd -clamp on My_Box-texture-1.png\n"), "{mtl}");
|
||||
assert_eq!(mtl.matches("map_Kd").count(), 1);
|
||||
// glTF: TEXCOORD_0 down from the top, and the picture embedded as a data URI.
|
||||
let g: Value = serde_json::from_str(&text(&mesh_files("Box", "gltf", &parts, &pictures).unwrap(), "Box.gltf")).unwrap();
|
||||
let prims = g["meshes"][0]["primitives"].as_array().unwrap();
|
||||
assert!(prims[0]["attributes"].get("TEXCOORD_0").is_none());
|
||||
let uv = &g["accessors"][prims[1]["attributes"]["TEXCOORD_0"].as_u64().unwrap() as usize];
|
||||
assert_eq!((uv["type"].as_str(), uv["count"].as_u64(), uv["componentType"].as_u64()), (Some("VEC2"), Some(6), Some(5126)));
|
||||
let view = &g["bufferViews"][uv["bufferView"].as_u64().unwrap() as usize];
|
||||
let data = vectorcraft_format::base64_decode(g["buffers"][0]["uri"].as_str().unwrap().split(',').nth(1).unwrap()).unwrap();
|
||||
let at = view["byteOffset"].as_u64().unwrap() as usize;
|
||||
let first: Vec<f32> = (0..2).map(|k| f32::from_le_bytes(data[at + 4 * k..at + 4 * k + 4].try_into().unwrap())).collect();
|
||||
assert_eq!(first, [0.0, 1.0]);
|
||||
let material = &g["materials"][prims[1]["material"].as_u64().unwrap() as usize];
|
||||
assert_eq!(material["pbrMetallicRoughness"]["baseColorTexture"]["index"], 0);
|
||||
assert_eq!(material["pbrMetallicRoughness"]["baseColorFactor"], serde_json::json!([1.0, 1.0, 1.0, 1.0]));
|
||||
assert_eq!(g["textures"][0]["source"], 0);
|
||||
assert_eq!(g["samplers"][0]["wrapS"], 33071);
|
||||
let image = g["images"][0]["uri"].as_str().unwrap().strip_prefix("data:image/png;base64,").unwrap();
|
||||
assert_eq!(vectorcraft_format::base64_decode(image).unwrap(), png);
|
||||
// USDA: st up from the bottom, read by a primvar reader into a UV texture of the PNG beside it.
|
||||
let files = mesh_files("Box", "usda", &parts, &pictures).unwrap();
|
||||
assert_eq!(files.iter().map(|(n, _)| n.as_str()).collect::<Vec<_>>(), ["Box.usda", "Box-texture-1.png"]);
|
||||
let u = text(&files, "Box.usda");
|
||||
assert_eq!(u.matches("primvars:st").count(), 1);
|
||||
assert!(u.contains("texCoord2f[] primvars:st = [(0, 0), (1, 0), (1, 1), (0, 0), (1, 1), (0, 1)]"), "{u}");
|
||||
assert!(u.contains("color3f inputs:diffuseColor.connect = </Box/Materials/Material_2/Texture.outputs:rgb>"), "{u}");
|
||||
assert!(u.contains("asset inputs:file = @Box-texture-1.png@") && u.contains("uniform token info:id = \"UsdUVTexture\""));
|
||||
assert!(u.contains("float2 inputs:st.connect = </Box/Materials/Material_2/Coordinates.outputs:result>"));
|
||||
assert!(u.contains("string inputs:varname = \"st\""));
|
||||
assert_eq!(u.matches('{').count(), u.matches('}').count());
|
||||
// USDZ: the layer first, then the picture, each on a 64-byte boundary.
|
||||
let zip = mesh_files("Box", "usdz", &parts, &pictures).unwrap().remove(0).1;
|
||||
let archive = super::super::zip::Archive::open(&zip, 8).unwrap();
|
||||
assert_eq!(archive.read("Box.usda", usize::MAX).unwrap().map(String::from_utf8), Some(Ok(u)));
|
||||
assert_eq!(archive.read("Box-texture-1.png", usize::MAX).unwrap(), Some(png.clone()));
|
||||
let u16_at = |at: usize| u16::from_le_bytes([zip[at], zip[at + 1]]) as usize;
|
||||
let u32_at = |at: usize| u32::from_le_bytes([zip[at], zip[at + 1], zip[at + 2], zip[at + 3]]) as usize;
|
||||
let first = 30 + u16_at(26) + u16_at(28);
|
||||
let second = first + u32_at(18);
|
||||
assert_eq!(&zip[second..second + 4], &[0x50, 0x4b, 0x03, 0x04], "the picture comes second");
|
||||
let data = second + 30 + u16_at(second + 26) + u16_at(second + 28);
|
||||
assert_eq!((first % 64, data % 64), (0, 0));
|
||||
assert_eq!(&zip[data..data + png.len()], png.as_slice());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_textured_face_that_is_not_opaque_takes_its_opacity_from_the_picture() {
|
||||
let (parts, mut pictures) = textured(b"picture");
|
||||
if let Some(t) = pictures[1].as_mut() {
|
||||
t.opacity = Some(Arc::new(b"gray".to_vec()));
|
||||
}
|
||||
// OBJ: the opacity map, written after its texture, is the MTL's map_d.
|
||||
let files = mesh_files("My Box", "obj", &parts, &pictures).unwrap();
|
||||
let names: Vec<&str> = files.iter().map(|(n, _)| n.as_str()).collect();
|
||||
assert_eq!(names, ["My_Box.obj", "My_Box.mtl", "My_Box-texture-1.png", "My_Box-texture-1-opacity.png"]);
|
||||
assert_eq!(files[3].1, b"gray");
|
||||
assert_eq!(mesh_file_names("My Box", "obj", &image_maps(&pictures)).unwrap(), names);
|
||||
let mtl = text(&files, "My_Box.mtl");
|
||||
assert!(mtl.contains("d 1\nillum 1\nmap_Kd -clamp on My_Box-texture-1.png\nmap_d -clamp on My_Box-texture-1-opacity.png\n"), "{mtl}");
|
||||
let g: Value = serde_json::from_str(&text(&mesh_files("Box", "gltf", &parts, &pictures).unwrap(), "Box.gltf")).unwrap();
|
||||
let material = &g["materials"][1];
|
||||
assert_eq!((material["pbrMetallicRoughness"]["baseColorFactor"][3].as_f64(), material["alphaMode"].as_str()), (Some(1.0), Some("BLEND")));
|
||||
let usda = mesh_files("Box", "usda", &parts, &pictures).unwrap();
|
||||
assert_eq!(usda.len(), 2, "USD reads the opacity from the texture's alpha");
|
||||
let u = text(&usda, "Box.usda");
|
||||
assert!(u.contains("float inputs:opacity.connect = </Box/Materials/Material_2/Texture.outputs:a>") && u.contains("float outputs:a"), "{u}");
|
||||
// An opaque textured face reads no opacity from its picture.
|
||||
let (_, plain) = textured(b"picture");
|
||||
let opaque = vec![square(RED), square([0.0, 0.0, 1.0, 1.0])];
|
||||
let u = text(&mesh_files("Box", "usda", &opaque, &plain).unwrap(), "Box.usda");
|
||||
assert!(!u.contains("outputs:a") && u.contains("float inputs:opacity = 1"), "{u}");
|
||||
let mtl = text(&mesh_files("Box", "obj", &opaque, &plain).unwrap(), "Box.mtl");
|
||||
assert!(!mtl.contains("map_d") && mtl.contains("Kd 1 1 1\nd 1\n"), "{mtl}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parts_sharing_a_picture_write_it_once() {
|
||||
let (mut parts, mut pictures) = textured(b"one");
|
||||
parts.push(square(BLUE));
|
||||
pictures.push(pictures[1].clone());
|
||||
assert_eq!(image_maps(&pictures), [false]);
|
||||
let files = mesh_files("Box", "obj", &parts, &pictures).unwrap();
|
||||
assert_eq!(files.len(), 3);
|
||||
assert_eq!(text(&files, "Box.mtl").matches("newmtl").count(), 2, "the blue parts share the textured material");
|
||||
assert_eq!(mesh_file_names("Box", "usda", &[false, true]).unwrap(), ["Box.usda", "Box-texture-1.png", "Box-texture-2.png"]);
|
||||
assert_eq!(mesh_file_names("A @b", "gltf", &[false, false]).unwrap(), ["A @b.gltf"]);
|
||||
assert_eq!(texture_name("A @b#c", 0), "A__b_c-texture-1.png");
|
||||
}
|
||||
|
||||
@@ -417,9 +417,13 @@ fn encode_carrying_at(
|
||||
}
|
||||
let (flat, flattened) = flatten_for(cmd, doc, set, p)?;
|
||||
vectorcraft_doc::cancel::check()?;
|
||||
if flattened {
|
||||
if let Some(o) = flattened {
|
||||
let kind = if set.standard.flattens() { set.standard.label() } else { set.compatibility.label() };
|
||||
notes.push(Note::loss(format!("transparency is flattened into opaque art and images ({kind} files have none): see the flattener preset")));
|
||||
let line_ppi = o.line_art_ppi.round() as u32;
|
||||
let grad_ppi = o.gradient_ppi.round() as u32;
|
||||
notes.push(Note::loss(format!(
|
||||
"transparency is flattened into opaque art and images ({kind} files have none) at {line_ppi} ppi line art and text, {grad_ppi} ppi gradients and meshes: see the flattener preset"
|
||||
)));
|
||||
}
|
||||
let r = super::super::rasterfx::export_pdf_with_report(flat.as_ref().unwrap_or(doc), &opts).map_err(|e| pdf_error(cmd, e))?;
|
||||
notes.extend(r.warnings.into_iter().map(Note::loss));
|
||||
@@ -438,9 +442,9 @@ pub const DEFAULT_FLATTENER: &str = "High Resolution";
|
||||
/// discarded overprints are dropped. Layers the pages leave out (non-printing ones, unless asked
|
||||
/// for) are left out of the flattening, hidden. → the document to write (`None`: `doc` as it is)
|
||||
/// and whether its transparency was flattened.
|
||||
fn flatten_for(cmd: &str, doc: &Document, set: &PdfSettings, p: &Value) -> Result<(Option<Document>, bool)> {
|
||||
fn flatten_for(cmd: &str, doc: &Document, set: &PdfSettings, p: &Value) -> Result<(Option<Document>, Option<FlattenOptions>)> {
|
||||
if !set.pdf13() {
|
||||
return Ok((None, false));
|
||||
return Ok((None, None));
|
||||
}
|
||||
let printed = if set.include_non_printing || set.create_layers { None } else { without_non_printing(&doc.layers) };
|
||||
let shown = printed.map(|layers| {
|
||||
@@ -456,8 +460,8 @@ fn flatten_for(cmd: &str, doc: &Document, set: &PdfSettings, p: &Value) -> Resul
|
||||
// its art: it is clipped to its regions (opaque inside them).
|
||||
o.clip_complex_regions = true;
|
||||
Ok(match flatten_document(shown.as_ref().unwrap_or(doc), &o)? {
|
||||
Some(flat) => (Some(flat), true),
|
||||
None => (shown, false),
|
||||
Some(flat) => (Some(flat), Some(o)),
|
||||
None => (shown, None),
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -500,6 +500,48 @@ pub(super) fn to_rgb(h: &Header<'_>, v: impl Fn(usize) -> f32, cmyk: &impl Fn([f
|
||||
}
|
||||
}
|
||||
|
||||
/// An opaque CMYK composite as its original 8- or 16-bit ink samples. Other modes,
|
||||
/// composites with transparency, and images beyond the native CMYK pixel or allocation limit return `None`.
|
||||
pub(super) fn decode_cmyk(bytes: &[u8], max_alloc: u64) -> Result<Option<craft_image_codecs::Image>, String> {
|
||||
use craft_image_codecs::{ChannelLayout, Image, SampleType};
|
||||
let mut r = Reader::new(bytes);
|
||||
let h = header(&mut r)?;
|
||||
if h.mode != Mode::Cmyk || (h.channels > 4 && merged_alpha(h.layers, h.psb)) {
|
||||
return Ok(None);
|
||||
}
|
||||
let pixels = u64::from(h.width) * u64::from(h.height);
|
||||
if pixels > vectorcraft_doc::cmyk::MAX_CMYK_PIXELS {
|
||||
return Ok(None);
|
||||
}
|
||||
let sample_bytes = usize::from(h.depth / 8);
|
||||
let samples = pixels * 4 * sample_bytes as u64;
|
||||
let icc = resources(h.resources, false)
|
||||
.find(|(id, _, _)| *id == 1039)
|
||||
.map(|(_, _, data)| data)
|
||||
.filter(|data| data.len() <= 16 << 20 && vectorcraft_doc::cmyk::icc_color_space(data) == Some(*b"CMYK"));
|
||||
if samples.saturating_mul(2).saturating_add(icc.map_or(0, |p| p.len() as u64)) > max_alloc {
|
||||
return Ok(None);
|
||||
}
|
||||
let count = pixels as usize;
|
||||
let data = channel_data(r.rest(), &h, 4, row_bytes(h.width as usize, h.depth))?;
|
||||
let mut out = Vec::with_capacity(samples as usize);
|
||||
for i in 0..count {
|
||||
for channel in 0..4 {
|
||||
let at = (channel * count + i) * sample_bytes;
|
||||
if h.depth == 8 {
|
||||
out.push(255 - data.get(at).copied().ok_or(TRUNCATED)?);
|
||||
} else {
|
||||
let pair = data.get(at..at + 2).ok_or(TRUNCATED)?.try_into().map_err(|_| TRUNCATED)?;
|
||||
out.extend((65535 - u16::from_be_bytes(pair)).to_ne_bytes());
|
||||
}
|
||||
}
|
||||
}
|
||||
let sample = if h.depth == 16 { SampleType::U16 } else { SampleType::U8 };
|
||||
let mut image = Image::from_raw(h.width, h.height, ChannelLayout::Cmyk, sample, out).map_err(|e| e.to_string())?;
|
||||
image.icc = icc.map(<[u8]>::to_vec);
|
||||
Ok(Some(image))
|
||||
}
|
||||
|
||||
/// A Photoshop document's merged image as straight RGBA. CMYK converts through `cmyk` (ink
|
||||
/// amounts 0..1 → sRGB). Fails, without allocating, when the image would need more than
|
||||
/// `max_alloc` bytes.
|
||||
|
||||
@@ -209,6 +209,8 @@ struct Row {
|
||||
options: Value,
|
||||
/// What makes two rows the same file: format, size, suffix and options.
|
||||
key: String,
|
||||
/// The row or the format's settings set `bleed` (a PDF row's own bleed, zero included).
|
||||
bleed_given: bool,
|
||||
}
|
||||
|
||||
impl Row {
|
||||
@@ -248,12 +250,19 @@ impl Row {
|
||||
}
|
||||
// A file per artboard is for viewing: it doesn't carry the whole document to edit.
|
||||
options.entry("preserveEditing").or_insert(json!(false));
|
||||
let bleed_given = options.get("bleed").is_some_and(|b| !b.is_null());
|
||||
let options = Value::Object(options);
|
||||
// A PDF preset (built-in or saved) becomes its settings.
|
||||
let options = if format.id == "pdf" { super::pdf::expand_preset(s, C, &options)?.into_owned() } else { options };
|
||||
// Two rows that would write the same bytes under the same name are one file.
|
||||
let key = format!("{}|{}|{suffix}|{options}", format.id, size.label());
|
||||
Ok(Self { format, size, suffix, folder, options, key })
|
||||
let mut row = Self { format, size, suffix, folder, options, key: String::new(), bleed_given };
|
||||
row.key = row.file_key();
|
||||
Ok(row)
|
||||
}
|
||||
|
||||
/// What makes two rows the same file: two rows that would write the same bytes under the same
|
||||
/// name are one file.
|
||||
fn file_key(&self) -> String {
|
||||
format!("{}|{}|{}|{}", self.format.id, self.size.label(), self.suffix, self.options)
|
||||
}
|
||||
|
||||
/// Formats that hold a whole document to edit (native, Illustrator, EPS): written from a
|
||||
@@ -525,6 +534,8 @@ fn rows_of(s: &Session, p: &Value, preset: Option<&str>) -> Result<Vec<Row>> {
|
||||
if let Some(m) = r.options.as_object_mut() {
|
||||
m.entry("antiAlias").or_insert_with(|| aa.clone());
|
||||
}
|
||||
// Two rows whose options are now the same are one file.
|
||||
r.key = r.file_key();
|
||||
}
|
||||
}
|
||||
Ok(rows)
|
||||
@@ -1137,17 +1148,22 @@ pub(crate) fn export(s: &mut Session, p: &Value, asked: &Value) -> Result<Value>
|
||||
let naming = Naming::of(&o, st.path.as_deref().unwrap_or(&st.doc.title))?;
|
||||
let selection = o.selection_mode()?;
|
||||
let selected = if selection.is_some() { selected_artwork(s)? } else { vec![] };
|
||||
let doc = s.doc()?.doc.clone();
|
||||
let original = s.doc()?.doc.clone();
|
||||
// Include Bleed: each artboard grown by the document's bleed.
|
||||
let doc = if o.include_bleed && doc.setup.has_bleed() {
|
||||
let mut d = (*doc).clone();
|
||||
let grown = o.include_bleed && original.setup.has_bleed();
|
||||
let doc = if grown {
|
||||
let mut d = (*original).clone();
|
||||
for a in &mut d.artboards {
|
||||
a.rect = doc.setup.bleed_rect(a.rect);
|
||||
a.rect = original.setup.bleed_rect(a.rect);
|
||||
}
|
||||
Arc::new(d)
|
||||
} else {
|
||||
doc
|
||||
original.clone()
|
||||
};
|
||||
// A PDF page of an artboard keeps the artboard as its TrimBox and puts its row's bleed around
|
||||
// it once: it is written from the document with the artboards as they are. Assets, layers and
|
||||
// a selection are written on a page of their own bounds, which Include Bleed doesn't grow.
|
||||
let ungrown = (grown && o.assets.is_none() && o.layers.is_none() && o.selection.is_none()).then_some(original);
|
||||
let crop = rows.iter().any(|r| r.format.id != "pdf");
|
||||
let items = items(&doc, &o, selection, &selected, &naming.filename, crop, true)?;
|
||||
// Before the folder is made or any row is written, with the artboards each file holds.
|
||||
@@ -1164,8 +1180,26 @@ pub(crate) fn export(s: &mut Session, p: &Value, asked: &Value) -> Result<Value>
|
||||
// Appearance of Black › Printing / Exporting for RGB raster rows.
|
||||
// Include Artboard Fill off: the encoders leave the background colors out.
|
||||
let fill = if o.include_artboard_fill == Some(false) { json!({ "includeArtboardFill": false }) } else { json!({}) };
|
||||
let rows = rows.into_iter().map(|r| Row { options: merge(with_black_output(s, &r.options), fill.clone()), ..r }).collect();
|
||||
let export = ScreenExport { cmd: C, o, rows, naming, items, unused, hidden: None };
|
||||
let rows = rows
|
||||
.into_iter()
|
||||
.map(|mut r| {
|
||||
// Include Bleed: a PDF row that sets no bleed of its own, and whose preset gives none,
|
||||
// puts the document's bleed around the artboard, and is the same file as a row that
|
||||
// asks for the document's bleed. A saved preset's bleed values stay, as they do in
|
||||
// that row.
|
||||
if ungrown.is_some() && r.format.id == "pdf" && !r.bleed_given && !pdf_bleeds(&r.options) {
|
||||
match r.options.get_mut("bleed").and_then(Value::as_object_mut) {
|
||||
Some(b) => {
|
||||
b.insert("useDocument".into(), json!(true));
|
||||
}
|
||||
None => r.options["bleed"] = json!({ "useDocument": true }),
|
||||
}
|
||||
r.key = r.file_key();
|
||||
}
|
||||
Row { options: merge(with_black_output(s, &r.options), fill.clone()), ..r }
|
||||
})
|
||||
.collect();
|
||||
let export = ScreenExport { cmd: C, o, rows, naming, items, unused, hidden: None, ungrown };
|
||||
match &mut s.screens_hand_off {
|
||||
Some(slot) => {
|
||||
*slot = Some(export);
|
||||
@@ -1175,6 +1209,14 @@ pub(crate) fn export(s: &mut Session, p: &Value, asked: &Value) -> Result<Value>
|
||||
}
|
||||
}
|
||||
|
||||
/// Do the PDF `options` (a built-in preset's settings under them) give the pages a bleed: the
|
||||
/// document's, or a value above 0 on some side? Options the PDF encoder refuses count as giving
|
||||
/// one, so they are left as they are for the encoder to refuse.
|
||||
fn pdf_bleeds(options: &Value) -> bool {
|
||||
super::pdf::settings(C, options)
|
||||
.map_or(true, |s| s.bleed.use_document || [s.bleed.top, s.bleed.bottom, s.bleed.left, s.bleed.right].iter().any(|b| *b > 0.0))
|
||||
}
|
||||
|
||||
/// An export as `document.exportForScreens` and `assets.export` take it from the session: the
|
||||
/// params, the format rows, the naming, and each item with the document it writes
|
||||
/// ([`Session::prepare_screen_export`]). [`ScreenExport::write`] encodes and writes its files
|
||||
@@ -1192,6 +1234,9 @@ pub struct ScreenExport {
|
||||
/// folder came from the `exportPreset` and is outside that request's read roots: the reply and
|
||||
/// the errors of [`ScreenExport::write`] name it as [`export_for_screens`] does.
|
||||
hidden: Option<(String, String)>,
|
||||
/// Include Bleed with artboards: the document with the artboards as they are, which PDF rows
|
||||
/// write (the items hold the artboards grown by the bleed).
|
||||
ungrown: Option<Arc<Document>>,
|
||||
}
|
||||
|
||||
impl Session {
|
||||
@@ -1252,7 +1297,7 @@ impl ScreenExport {
|
||||
|
||||
/// [`ScreenExport::write`].
|
||||
fn encode_and_write(export: ScreenExport, writer: &mut dyn FnMut(&str, &[u8]) -> Result<()>) -> Result<Value> {
|
||||
let ScreenExport { o, rows, naming, items, unused, .. } = export;
|
||||
let ScreenExport { o, rows, naming, items, unused, ungrown, .. } = export;
|
||||
let folder = o.folder.as_deref().filter(|f| !f.is_empty());
|
||||
if let Some(dir) = folder {
|
||||
create_dir(dir)?;
|
||||
@@ -1263,13 +1308,12 @@ fn encode_and_write(export: ScreenExport, writer: &mut dyn FnMut(&str, &[u8]) ->
|
||||
for text in unused {
|
||||
add_note(&mut notes, Note::setting(text));
|
||||
}
|
||||
// Include Bleed: a grown artboard already holds the bleed. Assets, layers and a selection are
|
||||
// written on a page of their own bounds, which it doesn't grow.
|
||||
let bleed_on_page = o.include_bleed && o.assets.is_none() && o.layers.is_none() && o.selection.is_none();
|
||||
// The document a PDF row writes: with Include Bleed, the artboards as they are.
|
||||
let pdf_doc = ungrown.as_deref();
|
||||
let mut write = |doc: &Document, format: &str, options: &Value| -> Result<Vec<u8>> {
|
||||
// The steps are the files: an encoder's own steps (artboards, pages) are not reported.
|
||||
let (bytes, given) = vectorcraft_doc::cancel::quiet(|| encode_with_notes(doc, format, options))?;
|
||||
for n in given.into_iter().filter(|n| !(bleed_on_page && n.text == super::pdf::BLEED_LEFT_OUT)) {
|
||||
for n in given {
|
||||
add_note(&mut notes, n);
|
||||
}
|
||||
Ok(bytes)
|
||||
@@ -1306,12 +1350,12 @@ fn encode_and_write(export: ScreenExport, writer: &mut dyn FnMut(&str, &[u8]) ->
|
||||
let bytes = if let Some(boards) = single {
|
||||
let mut options = r.options.clone();
|
||||
options["range"] = json!(boards.iter().map(|b| (b + 1).to_string()).collect::<Vec<_>>().join(", "));
|
||||
write(&item.doc, "pdf", &options)?
|
||||
write(pdf_doc.unwrap_or(&item.doc), "pdf", &options)?
|
||||
} else if let (Some(all), "pdf") = (&item.every_artboard, r.format.id) {
|
||||
// One page per artboard.
|
||||
let mut options = r.options.clone();
|
||||
options["range"] = json!("all");
|
||||
write(all, "pdf", &options)?
|
||||
write(pdf_doc.unwrap_or(all), "pdf", &options)?
|
||||
} else if r.whole_document() && item.artboard.is_some() {
|
||||
let b = item.artboard.unwrap_or(0);
|
||||
// That artboard alone, as Save's separateArtboards writes it: its art, not the others' (#3868).
|
||||
@@ -1334,7 +1378,8 @@ fn encode_and_write(export: ScreenExport, writer: &mut dyn FnMut(&str, &[u8]) ->
|
||||
}
|
||||
write(&d, r.format.id, &options)?
|
||||
} else {
|
||||
write(&item.doc, r.format.id, &r.options_for(item.region, item.artboard)?)?
|
||||
let doc = if r.format.id == "pdf" { pdf_doc.unwrap_or(&item.doc) } else { &item.doc };
|
||||
write(doc, r.format.id, &r.options_for(item.region, item.artboard)?)?
|
||||
};
|
||||
out.put(folder, o.zip, name, bytes, writer)?;
|
||||
files += 1;
|
||||
|
||||
@@ -799,7 +799,7 @@ fn unread_pdf_part(e: &str) -> String {
|
||||
|
||||
/// #4366: a `.ai`, or a PDF saved with the editing data, whose PDF part can't be read opens from
|
||||
/// its editing data, with a first note saying why. Pages picked, layers off or the editing data
|
||||
/// off keep the error, and so does editing data that can't be read.
|
||||
/// off keep the error. Editing data that can't be read keeps it too, followed by why.
|
||||
#[test]
|
||||
fn a_file_whose_pdf_part_cant_be_read_opens_from_its_editing_data() {
|
||||
let mut s = Session::new();
|
||||
@@ -817,10 +817,25 @@ fn a_file_whose_pdf_part_cant_be_read_opens_from_its_editing_data() {
|
||||
}
|
||||
for (name, file) in refused_files(b"%AI12_CompressedData not zlib", ai::page_pdf()) {
|
||||
let plain = open(&mut s, name, &file, json!({"editingData": false})).unwrap_err().to_string();
|
||||
assert_eq!(open(&mut s, name, &file, json!({})).unwrap_err().to_string(), plain, "{name}");
|
||||
let both = format!("{plain}; its editing data couldn't be read either (its zlib compression is damaged)");
|
||||
assert_eq!(open(&mut s, name, &file, json!({})).unwrap_err().to_string(), both, "{name}");
|
||||
for p in [json!({"pages": "1"}), json!({"layers": false})] {
|
||||
assert_eq!(open(&mut s, name, &file, p.clone()).unwrap_err().to_string(), plain, "{name}: {p}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// #4366: editing data stored in a form the reader doesn't take, beside a PDF part that can't be
|
||||
/// read, is named in the error.
|
||||
#[test]
|
||||
fn the_error_says_why_the_editing_data_couldnt_be_read() {
|
||||
let mut s = Session::new();
|
||||
let file = ai::ai_with_private_streams(&compressed(&ai::sample_data()), ai::page_pdf(), REFUSED_CONTENT, "/Filter /Bogus ");
|
||||
let plain = open(&mut s, "art.ai", &file, json!({"editingData": false})).unwrap_err().to_string();
|
||||
let e = open(&mut s, "art.ai", &file, json!({})).unwrap_err().to_string();
|
||||
assert_eq!(e, format!("{plain}; its editing data couldn't be read either (it is stored in a form that isn't read)"));
|
||||
}
|
||||
|
||||
/// A file saved in units of 10 points (`/UserUnit 10`, as in
|
||||
/// `an_ai_file_with_a_user_unit_opens_at_its_size_in_points`) whose PDF part can't be read opens
|
||||
/// from its editing data at its size in points.
|
||||
|
||||
@@ -135,26 +135,25 @@ fn formats_list_use_artboards() {
|
||||
assert!(opts("vectorcraft").get("useArtboards").is_none());
|
||||
}
|
||||
|
||||
/// An export's reply gives what the file loses before its notes on the options, whatever order
|
||||
/// the encoder gave them: the WebP encoder notes that lossy WebP isn't applied before the export
|
||||
/// notes the type it drew in the fallback font. With only notes on the options, they keep their
|
||||
/// order.
|
||||
/// An export's reply gives what the file loses before its notes on the options: the type the
|
||||
/// export drew in the fallback font comes before the note on an option WebP doesn't read. With
|
||||
/// only notes on the options, they keep their order.
|
||||
#[test]
|
||||
fn what_the_file_loses_comes_before_a_note_on_the_options() {
|
||||
let lossy = "lossy WebP isn't available yet: the file is lossless (exact, but larger)";
|
||||
let unused = "`interlaced` was not used: WebP files don't read it";
|
||||
let warnings = |s: &mut Session, p: Value| -> Vec<String> {
|
||||
let r = s.execute("document.export", &p).unwrap();
|
||||
r["warnings"].as_array().unwrap().iter().filter_map(Value::as_str).map(str::to_string).collect()
|
||||
};
|
||||
let mut s = session(60.0, 40.0, 1);
|
||||
assert_eq!(warnings(&mut s, json!({"format": "webp", "lossless": false})), [lossy]);
|
||||
assert_eq!(warnings(&mut s, json!({"format": "webp", "interlaced": true})), [unused]);
|
||||
s.execute("text.create", &json!({"x": 5, "y": 20, "text": "Ab", "font": "Nonexistent Sans Probe"})).unwrap();
|
||||
let w = warnings(&mut s, json!({"format": "webp", "lossless": false}));
|
||||
let w = warnings(&mut s, json!({"format": "webp", "interlaced": true}));
|
||||
assert_eq!(w.len(), 2, "{w:?}");
|
||||
assert!(w[0].contains("fallback font") && w[0].contains("Nonexistent Sans Probe"), "{w:?}");
|
||||
assert_eq!(w[1], lossy);
|
||||
assert_eq!(w[1], unused);
|
||||
// document.serialize gives them in the same order.
|
||||
let r = s.execute("document.serialize", &json!({"format": "webp", "lossless": false})).unwrap();
|
||||
let r = s.execute("document.serialize", &json!({"format": "webp", "interlaced": true})).unwrap();
|
||||
assert_eq!(r["warnings"], json!(w));
|
||||
}
|
||||
|
||||
|
||||
@@ -830,3 +830,78 @@ fn flattening_keeps_the_group_in_the_clipping_layer_when_the_layer_below_differs
|
||||
}
|
||||
assert!(wrong.is_empty(), "{wrong:#?}");
|
||||
}
|
||||
|
||||
/// #6861: Layer opacity, blend modes, sublayers with transparency, and empty transparent layers:
|
||||
/// PDF/X-1a, PDF/X-3, and PDF 1.3 automatically flatten and reduce transparency without failing,
|
||||
/// and the output contains no transparency dictionary or soft mask.
|
||||
#[test]
|
||||
fn pdfx_flattens_layer_and_sublayer_transparency() {
|
||||
let _g = crate::tests_colormgmt::GLOBAL.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let mut s = Session::new();
|
||||
run(&mut s, "file.new", json!({"width": 200, "height": 200, "colorMode": "cmyk"}));
|
||||
|
||||
// Bottom layer: base artwork
|
||||
let _layer1 = s.doc().unwrap().doc.layers[0].id.0;
|
||||
run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 80, "height": 80}));
|
||||
run(&mut s, "paint.setFill", json!({"color": {"c": 1.0, "m": 0.0, "y": 0.0, "k": 0.0}}));
|
||||
|
||||
// Middle layer with 50% opacity and Multiply blend mode
|
||||
let layer2 = run(&mut s, "layer.new", json!({}))["id"].as_u64().unwrap();
|
||||
run(&mut s, "shape.rectangle", json!({"x": 40, "y": 40, "width": 80, "height": 80}));
|
||||
run(&mut s, "paint.setFill", json!({"color": {"c": 0.0, "m": 1.0, "y": 0.0, "k": 0.0}}));
|
||||
run(&mut s, "transparency.set", json!({"ids": [layer2], "opacity": 50, "blendMode": "multiply"}));
|
||||
|
||||
// Sublayer inside layer2 with 70% opacity
|
||||
let sublayer = run(&mut s, "layer.newSublayer", json!({"parent": layer2}))["id"].as_u64().unwrap();
|
||||
run(&mut s, "shape.rectangle", json!({"x": 60, "y": 60, "width": 80, "height": 80}));
|
||||
run(&mut s, "paint.setFill", json!({"color": {"c": 0.0, "m": 0.0, "y": 1.0, "k": 0.0}}));
|
||||
run(&mut s, "transparency.set", json!({"ids": [sublayer], "opacity": 70}));
|
||||
|
||||
// Empty layer with opacity (must not leave /CA or /ca in output)
|
||||
let empty_layer = run(&mut s, "layer.new", json!({}))["id"].as_u64().unwrap();
|
||||
run(&mut s, "transparency.set", json!({"ids": [empty_layer], "opacity": 40}));
|
||||
|
||||
for standard in ["pdfX1a", "pdfX3"] {
|
||||
let (text, warnings) = pdf(&mut s, json!({"standard": standard}));
|
||||
assert!(text.starts_with("%PDF-1.3"), "{standard}");
|
||||
assert!(warnings.iter().any(|w| w.contains("flattened")), "{standard}: expected flattening warning");
|
||||
for no in ["/SMask", "/S/Transparency", "/ca ", "/CA "] {
|
||||
assert!(!text.contains(no), "{standard}: forbidden token '{no}' found in text:\n{text}");
|
||||
}
|
||||
// Verify it can be imported back and renders artwork
|
||||
let v = s.execute("document.exportPdf", &json!({"standard": standard})).unwrap();
|
||||
let bytes = vectorcraft_format::base64_decode(v["dataBase64"].as_str().unwrap()).unwrap();
|
||||
let imported = vectorcraft_pdf::import(&bytes).unwrap();
|
||||
assert!(!imported.layers.is_empty());
|
||||
let rendered = drawn(&imported);
|
||||
let non_white = rendered.pixels.as_chunks::<4>().0.iter().filter(|p| p[..3].iter().any(|c| *c < 240)).count();
|
||||
assert!(non_white > 1000, "{standard}: flattened artwork failed to render, only {non_white} pixels");
|
||||
}
|
||||
|
||||
// PDF 1.3 export with compatibility: 1.3
|
||||
let (text, warnings) = pdf(&mut s, json!({"compatibility": "1.3", "preserveEditing": false}));
|
||||
assert!(text.starts_with("%PDF-1.3"));
|
||||
assert!(warnings.iter().any(|w| w.contains("flattened")));
|
||||
for no in ["/SMask", "/S/Transparency", "/ca ", "/CA "] {
|
||||
assert!(!text.contains(no), "PDF 1.3: forbidden token '{no}' found in text");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pdf_outlining_does_not_wrap_layer_transparency_into_groups() {
|
||||
let _g = crate::tests_colormgmt::GLOBAL.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let mut s = Session::new();
|
||||
run(&mut s, "file.new", json!({"width": 200, "height": 200}));
|
||||
let layer1 = s.doc().unwrap().doc.layers[0].id.0;
|
||||
run(&mut s, "shape.rectangle", json!({"x": 10, "y": 10, "width": 80, "height": 80}));
|
||||
run(&mut s, "transparency.set", json!({"ids": [layer1], "opacity": 60}));
|
||||
|
||||
let o = crate::cmd::FlattenOptions { text_to_outlines: true, ..Default::default() };
|
||||
let doc = s.doc().unwrap().doc.clone();
|
||||
let flattened = crate::cmd::flatten::flatten_expanded(&doc, &o).unwrap();
|
||||
let resulting_doc = flattened.as_ref().unwrap_or(&doc);
|
||||
assert_eq!(resulting_doc.layers.len(), 1);
|
||||
let l = &resulting_doc.layers[0];
|
||||
assert_eq!(l.opacity, 0.6);
|
||||
assert!(!matches!(l.children().unwrap()[0].kind, vectorcraft_doc::NodeKind::Group { .. }));
|
||||
}
|
||||
|
||||
@@ -97,6 +97,132 @@ fn every_colour_mode_and_depth_reads() {
|
||||
assert_eq!(pixels(&psd(1, 1, (1, 1), 8, 8, &[0; 40], &[], &[], &raw(&[&[64]]))), [[64, 64, 64, 255]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cmyk_psd_place_keeps_the_native_ink_samples() {
|
||||
let f = psd(1, 4, (2, 1), 8, 4, &[], &[], &[], &raw(&[&[191, 255], &[127, 0], &[63, 127], &[223, 0]]));
|
||||
let p = json!({"name": "inks.psd", "dataBase64": vectorcraft_format::base64_encode(&f)});
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", &json!({"width": 40, "height": 20})).unwrap();
|
||||
let info = s.execute("file.place.info", &p).unwrap();
|
||||
assert_eq!(info["colorMode"], "CMYK");
|
||||
let placed = s.execute("file.place", &p).unwrap();
|
||||
let id = NodeId(placed["ids"][0].as_u64().unwrap());
|
||||
let d = &s.doc().unwrap().doc;
|
||||
let NodeKind::Image(im) = &d.node(id).unwrap().kind else { panic!("placed PSD is an image") };
|
||||
let blob = d.images.get(&im.key).unwrap();
|
||||
assert!(blob.is_cmyk());
|
||||
assert_eq!(blob.cmyk().unwrap().data, [64, 128, 192, 32, 0, 255, 128, 255]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cmyk_psd_native_budget_keeps_the_rgba_fallback_available() {
|
||||
let bytes = psd(1, 4, (2, 1), 16, 4, &[], &[], &[], &raw(&[&[0xff; 4], &[0xff; 4], &[0xff; 4], &[0; 4]]));
|
||||
assert!(super::psdread::decode_cmyk(&bytes, 24).unwrap().is_none());
|
||||
assert_eq!(decode(&bytes, 24, naive).unwrap().into_raw(), [0, 0, 0, 255, 0, 0, 0, 255]);
|
||||
assert!(decode(&bytes, 1, naive).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cmyk_psd_depth_and_compression_preserve_exact_samples() {
|
||||
for version in [1, 2] {
|
||||
for depth in [8, 16] {
|
||||
let values = if depth == 8 { [191u16, 127, 63, 223] } else { [0xcdef, 0x89ab, 0x4567, 0x0123] };
|
||||
let planes: Vec<Vec<u8>> = values.iter().map(|v| if depth == 8 { vec![*v as u8] } else { v.to_be_bytes().to_vec() }).collect();
|
||||
let uncompressed = planes.concat();
|
||||
for method in 0..=3u16 {
|
||||
let mut data = method.to_be_bytes().to_vec();
|
||||
match method {
|
||||
0 => data.extend(&uncompressed),
|
||||
1 => {
|
||||
for p in &planes {
|
||||
let count = (p.len() + 1) as u32;
|
||||
if version == 2 { data.extend(count.to_be_bytes()) } else { data.extend((count as u16).to_be_bytes()) }
|
||||
}
|
||||
for p in &planes {
|
||||
data.push((p.len() - 1) as u8);
|
||||
data.extend(p);
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
// One sample per row has the same bytes with or without prediction.
|
||||
let mut z = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
|
||||
std::io::Write::write_all(&mut z, &uncompressed).unwrap();
|
||||
data.extend(z.finish().unwrap());
|
||||
}
|
||||
}
|
||||
let bytes = psd(version, 4, (1, 1), depth, 4, &[], &[], &[], &data);
|
||||
let img = raster_image(&bytes).unwrap();
|
||||
assert!(img.blob.is_cmyk(), "version {version}, depth {depth}, compression {method}");
|
||||
assert_eq!(img.blob.is_cmyk16(), depth == 16);
|
||||
let decoded = craft_image_codecs::decode(&img.blob.bytes).unwrap();
|
||||
let expected: Vec<u8> =
|
||||
values.iter().flat_map(|v| if depth == 8 { vec![255 - *v as u8] } else { (65535 - v).to_ne_bytes().to_vec() }).collect();
|
||||
assert_eq!(decoded.data(), expected);
|
||||
assert!(super::psdread::decode_cmyk(&bytes, 1).unwrap().is_none());
|
||||
assert!(super::psdread::decode_cmyk(&bytes[..bytes.len() - data.len() + 2], 1 << 30).is_err());
|
||||
}
|
||||
}
|
||||
}
|
||||
let planes: [&[u8]; 5] = [&[255], &[255], &[255], &[255], &[128]];
|
||||
let saved = psd(1, 5, (1, 1), 8, 4, &[], &[], &[], &raw(&planes));
|
||||
assert!(raster_image(&saved).unwrap().blob.is_cmyk(), "a saved selection is not transparency");
|
||||
let alpha = psd(1, 5, (1, 1), 8, 4, &[], &[], &layer_count(-1, false), &raw(&planes));
|
||||
let img = raster_image(&alpha).unwrap();
|
||||
assert!(!img.blob.is_cmyk());
|
||||
assert_eq!(craft_image_codecs::decode(&img.blob.bytes).unwrap().to_rgba8()[3], 128);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cmyk_psd_links_keep_inks_profile_resolution_and_clipping() {
|
||||
let profile = vectorcraft_color::cms::icc_bytes(vectorcraft_color::cms::GENERIC_CMYK).unwrap();
|
||||
let mut res = Vec::new();
|
||||
res.extend((144u32 << 16).to_be_bytes());
|
||||
res.extend([0, 1, 0, 1]);
|
||||
res.extend((144u32 << 16).to_be_bytes());
|
||||
res.extend([0, 1, 0, 1]);
|
||||
let make = |clip: &[u8], ink: u8| {
|
||||
let resources = [resource(1039, b"", &profile), resource(1005, b"", &res), clip.to_vec()].concat();
|
||||
psd(1, 4, (2, 1), 8, 4, &[], &resources, &[], &raw(&[&[255 - ink; 2], &[127; 2], &[63; 2], &[223; 2]]))
|
||||
};
|
||||
let dir = vectorcraft_testkit::TempDir::new("psd-cmyk-links");
|
||||
let cut = write_file(&dir, "cut.psd", &make(&triangle_resources(), 64));
|
||||
let square = write_file(&dir, "square.psd", &make(&square_resources(), 96));
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", &json!({"width": 20, "height": 10, "colorMode": "cmyk"})).unwrap();
|
||||
assert_eq!(s.execute("file.place.info", &json!({"path": cut})).unwrap()["colorMode"], "CMYK");
|
||||
let r = s.execute("file.place", &json!({"path": cut, "at": [0.5, 0.25]})).unwrap();
|
||||
let group = NodeId(r["ids"][0].as_u64().unwrap());
|
||||
let id = r["image"].as_u64().unwrap();
|
||||
assert_eq!(r["width"], 1.0);
|
||||
assert_eq!(r["height"], 0.5);
|
||||
let check = |s: &mut Session, ink, linked| {
|
||||
let info = s.execute("links.info", &json!({"id": id})).unwrap();
|
||||
assert_eq!(info["colorMode"], "CMYK");
|
||||
assert_eq!(info["linked"], linked);
|
||||
assert_eq!(info["ppi"], json!([144.0, 144.0]));
|
||||
let d = &s.doc().unwrap().doc;
|
||||
let NodeKind::Image(im) = &d.node(NodeId(id)).unwrap().kind else { panic!("placed image") };
|
||||
let blob = d.images.get(&im.key).unwrap();
|
||||
assert_eq!(blob.cmyk().unwrap().data, [ink, 128, 192, 32, ink, 128, 192, 32]);
|
||||
assert_eq!(blob.cmyk_icc_profile().as_deref(), Some(profile.as_ref()));
|
||||
assert_eq!(
|
||||
super::load::image_clip(blob),
|
||||
Some(clipping_path(&make(&if ink == 64 { triangle_resources() } else { square_resources() }, ink)).unwrap())
|
||||
);
|
||||
};
|
||||
check(&mut s, 64, true);
|
||||
let triangle = clip_group(&s.doc().unwrap().doc, group);
|
||||
s.execute("links.relink", &json!({"ids": [id], "path": square})).unwrap();
|
||||
check(&mut s, 96, true);
|
||||
assert_ne!(clip_group(&s.doc().unwrap().doc, group).0, triangle.0);
|
||||
std::fs::write(&square, make(&triangle_resources(), 64)).unwrap();
|
||||
s.execute("links.update", &json!({"ids": [id]})).unwrap();
|
||||
check(&mut s, 64, true);
|
||||
assert_eq!(clip_group(&s.doc().unwrap().doc, group), triangle);
|
||||
s.execute("links.embed", &json!({"ids": [id]})).unwrap();
|
||||
check(&mut s, 64, false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transparency_comes_back_straight_and_extra_channels_without_it_stay_out() {
|
||||
// Half-transparent red, stored on white: (255, 127, 127) with alpha 128.
|
||||
|
||||
@@ -546,20 +546,19 @@ fn type_in_a_missing_family_is_named_once_for_every_format() {
|
||||
assert!(fallback[0].contains("Nonexistent Sans Probe"), "{fallback:?}");
|
||||
}
|
||||
|
||||
/// What a later file loses comes before a note on the options that an earlier file gave: the
|
||||
/// first artboard's WebP gives only the lossy WebP note, the second's also says its type doesn't
|
||||
/// fit.
|
||||
/// What a later file loses comes before a note on the options: the second artboard's WebP says
|
||||
/// its type doesn't fit, before the note on the row's option that WebP doesn't read.
|
||||
#[test]
|
||||
fn what_any_file_loses_comes_before_the_notes_on_the_options() {
|
||||
let mut s = session(2);
|
||||
let second = s.doc().unwrap().doc.artboards[1].rect;
|
||||
let area = json!({"width": 30, "height": 8});
|
||||
s.execute("text.create", &json!({"x": second.x0 + 2.0, "y": second.y0 + 2.0, "size": 12, "area": area, "text": "Ab\nCd\nEf\nGh"})).unwrap();
|
||||
let r = export(&mut s, json!({"formats": [{"format": "webp", "lossless": false}]}));
|
||||
let r = export(&mut s, json!({"formats": [{"format": "webp", "interlaced": true}]}));
|
||||
let warnings: Vec<&str> = r["warnings"].as_array().unwrap().iter().filter_map(Value::as_str).collect();
|
||||
assert_eq!(warnings.len(), 2, "{warnings:?}");
|
||||
assert!(warnings[0].contains("doesn't fit its frame"), "{warnings:?}");
|
||||
assert!(warnings[1].starts_with("lossy WebP"), "{warnings:?}");
|
||||
assert!(warnings[1].starts_with("`formats[0].interlaced` was not used"), "{warnings:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -594,7 +593,8 @@ fn include_bleed_grows_each_artboard() {
|
||||
assert_eq!(size(&files(&r)[0].1), (40, 30), "without it, the artboard alone");
|
||||
}
|
||||
|
||||
/// Include Bleed puts the bleed on a PDF/X row's page, so the row doesn't warn that it leaves the bleed out.
|
||||
/// Include Bleed puts the bleed on a PDF/X row's page, so the row doesn't warn that it leaves the
|
||||
/// bleed out, unless the row sets a bleed of 0 itself.
|
||||
#[test]
|
||||
fn include_bleed_pdfx_rows_do_not_warn_about_the_bleed() {
|
||||
let mut s = session(1);
|
||||
@@ -603,11 +603,103 @@ fn include_bleed_pdfx_rows_do_not_warn_about_the_bleed() {
|
||||
let row = json!([{"format": "pdf", "standard": "pdfX4"}]);
|
||||
assert!(warned(&export(&mut s, json!({"formats": row}))));
|
||||
assert!(!warned(&export(&mut s, json!({"includeBleed": true, "formats": row}))));
|
||||
let zero = json!([{"format": "pdf", "standard": "pdfX4", "bleed": {"top": 0, "bottom": 0, "left": 0, "right": 0}}]);
|
||||
assert!(warned(&export(&mut s, json!({"includeBleed": true, "formats": zero}))), "the row's own bleed of 0 leaves the bleed out");
|
||||
// A selection is written on a page of its own bounds, which Include Bleed doesn't grow.
|
||||
s.execute("shape.rectangle", &json!({"x": 5, "y": 5, "width": 10, "height": 10})).unwrap();
|
||||
assert!(warned(&export(&mut s, json!({"includeBleed": true, "selection": "one", "formats": row}))));
|
||||
}
|
||||
|
||||
/// Each `[x0 y0 x1 y1]` that follows `key` in a PDF's bytes, in the order the file has them, read
|
||||
/// as text without VectorCraft's PDF reader (PDF 32000-1:2008, 14.11.2, Page Boundaries).
|
||||
fn raw_boxes(pdf: &[u8], key: &str) -> Vec<[f64; 4]> {
|
||||
let text = String::from_utf8_lossy(pdf);
|
||||
text.match_indices(key)
|
||||
.map(|(at, _)| {
|
||||
let mut words = text[at + key.len()..].split(|c: char| c.is_whitespace() || matches!(c, '[' | ']')).filter(|w| !w.is_empty());
|
||||
std::array::from_fn(|_| words.next().and_then(|w| w.parse().ok()).unwrap_or(f64::NAN))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// A page's MediaBox, BleedBox and TrimBox sizes `(width, height)` in points, and the trim's
|
||||
/// distance from the bleed box's left and bottom edges.
|
||||
type PageSizes = ((f64, f64), (f64, f64), (f64, f64), (f64, f64));
|
||||
|
||||
/// [`PageSizes`] of each page of `pdf`.
|
||||
fn page_sizes(pdf: &[u8]) -> Vec<PageSizes> {
|
||||
let size = |b: &[f64; 4]| (b[2] - b[0], b[3] - b[1]);
|
||||
let (media, bleed, trim) = (raw_boxes(pdf, "/MediaBox"), raw_boxes(pdf, "/BleedBox"), raw_boxes(pdf, "/TrimBox"));
|
||||
assert!(!trim.is_empty() && media.len() == trim.len() && bleed.len() == trim.len(), "a MediaBox, BleedBox and TrimBox per page");
|
||||
(0..trim.len()).map(|i| (size(&media[i]), size(&bleed[i]), size(&trim[i]), (trim[i][0] - bleed[i][0], trim[i][1] - bleed[i][1]))).collect()
|
||||
}
|
||||
|
||||
/// With Include Bleed, a PDF page keeps the artboard as its TrimBox and puts the bleed around it
|
||||
/// once (PDF 32000-1:2008, 14.11.2: the trim box is the finished page, the bleed box holds it): the
|
||||
/// document's bleed when the row asks for it or sets none, else the row's own values.
|
||||
#[test]
|
||||
fn include_bleed_pdf_pages_trim_at_the_artboard() {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", &json!({"width": 100, "height": 100, "artboards": 2})).unwrap();
|
||||
s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap();
|
||||
s.execute("document.setup", &json!({"bleed": 9})).unwrap();
|
||||
let pages = |s: &mut Session, p: Value| -> Vec<PageSizes> {
|
||||
let r = export(s, p);
|
||||
files(&r).iter().filter(|(n, _)| n.ends_with(".pdf")).flat_map(|(_, b)| page_sizes(b)).collect()
|
||||
};
|
||||
let one = |media: f64, bleed: f64, trim: f64| ((media, media), (bleed, bleed), (trim, trim), ((bleed - trim) / 2.0, (bleed - trim) / 2.0));
|
||||
let document = json!({"format": "pdf", "bleed": {"useDocument": true}});
|
||||
let sides = |b: f64| json!({"top": b, "bottom": b, "left": b, "right": b});
|
||||
for (p, want) in [
|
||||
(json!({"includeBleed": true, "artboard": 0, "formats": [document]}), one(118.0, 118.0, 100.0)),
|
||||
(json!({"includeBleed": true, "artboard": 0, "formats": [{"format": "pdf"}]}), one(118.0, 118.0, 100.0)),
|
||||
(json!({"includeBleed": true, "artboard": 0, "formats": [{"format": "pdf", "preset": "High Quality Print"}]}), one(118.0, 118.0, 100.0)),
|
||||
(json!({"includeBleed": true, "artboard": 0, "formats": [{"format": "pdf", "bleed": sides(3.0)}]}), one(106.0, 106.0, 100.0)),
|
||||
(json!({"includeBleed": true, "artboard": 0, "formats": [{"format": "pdf", "bleed": sides(0.0)}]}), one(100.0, 100.0, 100.0)),
|
||||
(json!({"artboard": 0, "formats": [document]}), one(118.0, 118.0, 100.0)),
|
||||
(json!({"artboard": 0, "formats": [{"format": "pdf"}]}), one(100.0, 100.0, 100.0)),
|
||||
] {
|
||||
assert_eq!(pages(&mut s, p.clone()), [want], "{p}");
|
||||
}
|
||||
// Every page of a single file and of the Full Document, each artboard its own trim.
|
||||
for p in [
|
||||
json!({"includeBleed": true, "pdfs": "single", "formats": [document]}),
|
||||
json!({"includeBleed": true, "fullDocument": true, "formats": [document]}),
|
||||
] {
|
||||
assert_eq!(pages(&mut s, p.clone()), [one(118.0, 118.0, 100.0); 2], "{p}");
|
||||
}
|
||||
// A row with printer's marks: the sheet grows past the bleed box for them, around the same trim.
|
||||
let marked = pages(
|
||||
&mut s,
|
||||
json!({"includeBleed": true, "artboard": 0, "formats": [{"format": "pdf", "bleed": {"useDocument": true}, "marks": {"trim": true}}]}),
|
||||
);
|
||||
let [(media, bleed, trim, at)] = marked[..] else { panic!("one page: {marked:?}") };
|
||||
assert_eq!((bleed, trim, at), ((118.0, 118.0), (100.0, 100.0), (9.0, 9.0)));
|
||||
assert!(media.0 > 118.0 && media.1 > 118.0, "{media:?}");
|
||||
// A row that sets no bleed writes the same file as one that asks for the document's: one file.
|
||||
let r = export(&mut s, json!({"includeBleed": true, "artboard": 0, "formats": [{"format": "pdf"}, document]}));
|
||||
assert_eq!(names(&r).len(), 1, "{:?}", names(&r));
|
||||
// So does it with a top-level anti-aliasing mode, which both rows take.
|
||||
let r = export(&mut s, json!({"includeBleed": true, "artboard": 0, "antiAlias": "art", "formats": [{"format": "pdf"}, document]}));
|
||||
assert_eq!(names(&r).len(), 1, "{:?}", names(&r));
|
||||
// And with a saved PDF preset, which writes out every bleed value for both rows.
|
||||
s.execute("pdf.preset.save", &json!({"name": "Saved Default"})).unwrap();
|
||||
let saved = |bleed: Option<Value>| {
|
||||
let mut row = json!({"format": "pdf", "preset": "Saved Default"});
|
||||
if let Some(b) = bleed {
|
||||
row["bleed"] = b;
|
||||
}
|
||||
row
|
||||
};
|
||||
let r = export(&mut s, json!({"includeBleed": true, "artboard": 0, "formats": [saved(None), saved(Some(json!({"useDocument": true})))]}));
|
||||
assert_eq!(names(&r).len(), 1, "{:?}", names(&r));
|
||||
assert_eq!(pages(&mut s, json!({"includeBleed": true, "artboard": 0, "formats": [saved(None)]})), [one(118.0, 118.0, 100.0)]);
|
||||
// A raster row of the same export still holds the bleed in its pixels.
|
||||
let r = export(&mut s, json!({"includeBleed": true, "artboard": 0, "formats": [document, {"format": "png"}]}));
|
||||
let png = files(&r).into_iter().find(|(n, _)| n.ends_with(".png")).unwrap().1;
|
||||
assert_eq!(size(&png), (118, 118));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn png_8_rows_write_indexed_colour() {
|
||||
let mut s = session(1);
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use serde_json::json;
|
||||
use vectorcraft_doc::Document;
|
||||
use vectorcraft_doc::{Document, Node, NodeKind};
|
||||
|
||||
use super::*;
|
||||
|
||||
@@ -212,6 +212,44 @@ fn a_chosen_artboard_s_svg_keeps_nested_brush_art_but_not_unpainted_or_clipped_a
|
||||
assert!(kept.node(compounds[1]).is_some(), "a compound path that is brushed itself");
|
||||
}
|
||||
|
||||
/// The art over an artboard, among 300 instances with drop shadows and 2,000 symbols, is found
|
||||
/// reading the symbol list once, and keeps the instances over it.
|
||||
#[test]
|
||||
fn art_over_an_artboard_reads_the_symbol_list_once() {
|
||||
let mut d = Document::new(100.0, 100.0);
|
||||
let square = |d: &mut Document, side: f64| {
|
||||
let r = vectorcraft_geom::Rect::new(-side, -side, side, side);
|
||||
let ap =
|
||||
vectorcraft_doc::Appearance::basic(vectorcraft_color::Paint::solid(vectorcraft_color::Color::BLACK), vectorcraft_color::Paint::None, 0.0);
|
||||
Arc::new(Node::path(d.alloc_id(), vectorcraft_geom::shapes::rectangle(r), ap))
|
||||
};
|
||||
for i in 0..2000 {
|
||||
let art = square(&mut d, 0.5);
|
||||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: format!("Filler {i}"), art });
|
||||
}
|
||||
let art = square(&mut d, 2.0);
|
||||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Mark".into(), art });
|
||||
let layer = d.layers[0].id;
|
||||
// Twenty rows of 15: the first ten over the artboard, the rest below it.
|
||||
let ids: Vec<_> = (0..300)
|
||||
.map(|i| {
|
||||
let xf = vectorcraft_geom::Affine::translate((f64::from(i % 15) * 6.0 + 5.0, f64::from(i / 15) * 10.0 + 5.0));
|
||||
let mut n = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Mark".into(), xf });
|
||||
n.appearance.effects.push(vectorcraft_doc::Effect {
|
||||
id: "stylize.dropShadow".into(),
|
||||
params: json!({"x": 1, "y": 1, "blur": 0}),
|
||||
visible: true,
|
||||
});
|
||||
d.insert(Some(layer), usize::MAX, n).unwrap()
|
||||
})
|
||||
.collect();
|
||||
let before = vectorcraft_doc::symbols_read();
|
||||
let kept = export::art_over(&d, d.artboards[0].rect, &mut vectorcraft_render::Renderer::new());
|
||||
let read = vectorcraft_doc::symbols_read() - before;
|
||||
assert!(read <= d.symbols.len(), "{read} symbols read, {} in the document", d.symbols.len());
|
||||
assert_eq!(ids.iter().filter(|id| kept.node(**id).is_some()).count(), 150);
|
||||
}
|
||||
|
||||
/// #3544: an SVG of one artboard on its own (an `artboard` or `range`, Export for Screens, an asset)
|
||||
/// has the artboard's (or asset's) name as `<title>`; Save's SVG and Export for Screens' Full
|
||||
/// Document keep the document's.
|
||||
|
||||
@@ -53,41 +53,115 @@ fn text_export_writes_the_stories_in_stacking_order() {
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
/// The chunk types of RIFF WebP file `file`, in order.
|
||||
fn webp_chunks(file: &[u8]) -> Vec<[u8; 4]> {
|
||||
assert_eq!((&file[..4], &file[8..12]), (&b"RIFF"[..], &b"WEBP"[..]));
|
||||
let mut chunks = Vec::new();
|
||||
let mut at = 12;
|
||||
while at + 8 <= file.len() {
|
||||
let len = u32::from_le_bytes([file[at + 4], file[at + 5], file[at + 6], file[at + 7]]) as usize;
|
||||
chunks.push([file[at], file[at + 1], file[at + 2], file[at + 3]]);
|
||||
at += 8 + len + len % 2;
|
||||
}
|
||||
chunks
|
||||
}
|
||||
|
||||
/// The size and straight RGBA pixels of image file `file`.
|
||||
fn rgba(file: &[u8]) -> (u32, u32, Vec<u8>) {
|
||||
let img = craft_image_codecs::decode(file).unwrap();
|
||||
let (w, h) = img.dimensions();
|
||||
(w, h, img.to_rgba8())
|
||||
}
|
||||
|
||||
/// A 120 × 80 pt document filled with a grid of rectangles in 96 colors.
|
||||
fn varied_art() -> Session {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", &json!({"width": 120, "height": 80})).unwrap();
|
||||
for row in 0..8 {
|
||||
for col in 0..12 {
|
||||
s.execute("shape.rectangle", &json!({"x": col * 10, "y": row * 10, "width": 10, "height": 10})).unwrap();
|
||||
let color = format!("#{:02x}{:02x}{:02x}", col * 21, row * 32, (col * 7 + row * 23) % 256);
|
||||
s.execute("paint.setFill", &json!({"color": color})).unwrap();
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn webp_is_lossless_and_says_so_when_lossy_is_asked_for() {
|
||||
fn webp_is_lossless_by_default_and_lossy_when_asked() {
|
||||
let mut s = varied_art();
|
||||
let export = |s: &mut Session, p: Value| -> (Vec<u8>, Value) {
|
||||
let r = s.execute("document.export", &merge(json!({"format": "webp", "background": "white"}), p)).unwrap();
|
||||
(b64(&r), r["warnings"].clone())
|
||||
};
|
||||
let (lossless, warnings) = export(&mut s, json!({}));
|
||||
assert_eq!(webp_chunks(&lossless), [*b"VP8L"], "lossless by default");
|
||||
assert_eq!(warnings, json!([]));
|
||||
// Quality doesn't change a lossless file.
|
||||
assert_eq!(export(&mut s, json!({"lossless": true, "quality": 10})).0, lossless);
|
||||
|
||||
let (lossy, warnings) = export(&mut s, json!({"lossless": false}));
|
||||
assert_eq!(webp_chunks(&lossy), [*b"VP8 "], "opaque art is a plain lossy file");
|
||||
assert_eq!(warnings, json!([]), "no note: the file is lossy");
|
||||
assert_eq!(export(&mut s, json!({"lossless": false, "quality": 90})).0, lossy, "quality 90 by default");
|
||||
// At quality 90 each channel stays within 4 levels of the exact pixels on average.
|
||||
let ((w, h, exact), (lw, lh, near)) = (rgba(&lossless), rgba(&lossy));
|
||||
assert_eq!((lw, lh), (w, h));
|
||||
assert_eq!((w, h), (120, 80));
|
||||
let diff: u64 = exact.iter().zip(&near).map(|(a, b)| u64::from(a.abs_diff(*b))).sum();
|
||||
let mean = diff as f64 / exact.len() as f64;
|
||||
assert!(mean <= 4.0, "mean difference {mean}");
|
||||
// Lower quality, smaller file.
|
||||
let low = export(&mut s, json!({"lossless": false, "quality": 10})).0;
|
||||
let high = export(&mut s, json!({"lossless": false, "quality": 95})).0;
|
||||
assert_eq!(webp_chunks(&low), [*b"VP8 "]);
|
||||
assert!(low.len() < high.len(), "{} vs {} bytes", low.len(), high.len());
|
||||
for q in [0, 100] {
|
||||
assert_eq!(webp_chunks(&export(&mut s, json!({"lossless": false, "quality": q})).0), [*b"VP8 "], "quality {q}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lossy_webp_keeps_translucent_pixels() {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", &json!({"width": 30, "height": 20})).unwrap();
|
||||
s.execute("shape.rectangle", &json!({"x": 2, "y": 2, "width": 10, "height": 10})).unwrap();
|
||||
let r = s.execute("document.export", &json!({"format": "webp"})).unwrap();
|
||||
let file = b64(&r);
|
||||
assert_eq!((&file[..4], &file[8..12], &file[12..16]), (&b"RIFF"[..], &b"WEBP"[..], &b"VP8L"[..]), "lossless bitstream");
|
||||
assert_eq!(r["warnings"], json!([]));
|
||||
let r = s.execute("document.export", &json!({"format": "webp", "lossless": false, "quality": 60, "background": "black"})).unwrap();
|
||||
assert_eq!(&b64(&r)[12..16], b"VP8L");
|
||||
assert!(r["warnings"][0].as_str().unwrap().contains("lossless"), "{r}");
|
||||
assert_eq!(
|
||||
craft_image_codecs::decode(&b64(&r))
|
||||
.map(|__cimg| {
|
||||
let (__w, __h) = __cimg.dimensions();
|
||||
match (__cimg.layout(), __cimg.sample_type()) {
|
||||
(craft_image_codecs::ChannelLayout::Gray, craft_image_codecs::SampleType::U8) => {
|
||||
image::DynamicImage::ImageLuma8(image::GrayImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
|
||||
}
|
||||
(craft_image_codecs::ChannelLayout::GrayA, craft_image_codecs::SampleType::U8) => {
|
||||
image::DynamicImage::ImageLumaA8(image::GrayAlphaImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
|
||||
}
|
||||
(craft_image_codecs::ChannelLayout::Rgb, craft_image_codecs::SampleType::U8) => {
|
||||
image::DynamicImage::ImageRgb8(image::RgbImage::from_raw(__w, __h, __cimg.into_data()).unwrap())
|
||||
}
|
||||
_ => image::DynamicImage::ImageRgba8(image::RgbaImage::from_raw(__w, __h, __cimg.to_rgba8()).unwrap()),
|
||||
}
|
||||
})
|
||||
.unwrap()
|
||||
.to_rgba8()
|
||||
.get_pixel(29, 19)
|
||||
.0,
|
||||
[0, 0, 0, 255]
|
||||
);
|
||||
s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 20, "height": 20})).unwrap();
|
||||
s.execute("paint.setFill", &json!({"color": "#0000ff"})).unwrap();
|
||||
s.execute("transparency.set", &json!({"opacity": 50})).unwrap();
|
||||
let file = |s: &mut Session, lossless: bool| b64(&s.execute("document.export", &json!({"format": "webp", "lossless": lossless})).unwrap());
|
||||
let (lossless, lossy) = (file(&mut s, true), file(&mut s, false));
|
||||
assert_eq!(webp_chunks(&lossy), [*b"VP8X", *b"ALPH", *b"VP8 "]);
|
||||
let ((w, h, exact), (lw, lh, near)) = (rgba(&lossless), rgba(&lossy));
|
||||
assert_eq!((lw, lh), (w, h));
|
||||
let at = |px: &[u8], x: u32, y: u32| -> [u8; 4] {
|
||||
let i = 4 * (y * w + x) as usize;
|
||||
[px[i], px[i + 1], px[i + 2], px[i + 3]]
|
||||
};
|
||||
// The alpha is written exactly: half covered under the rectangle, clear past it.
|
||||
let alphas = |px: &[u8]| px.chunks(4).map(|p| p[3]).collect::<Vec<u8>>();
|
||||
assert_eq!(alphas(&near), alphas(&exact));
|
||||
assert!((120..=135).contains(&at(&near, 5, 5)[3]), "{:?}", at(&near, 5, 5));
|
||||
assert_eq!(at(&near, 28, 10)[3], 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn webp_quality_out_of_its_range_is_refused() {
|
||||
let mut s = varied_art();
|
||||
for q in [json!(101), json!(255), json!(256), json!(-1), json!(60.5), json!("high"), json!(true)] {
|
||||
let p = json!({"format": "webp", "lossless": false, "quality": q});
|
||||
let e = s.execute("document.export", &p).unwrap_err().to_string();
|
||||
assert!(e.contains("quality"), "{q}: {e}");
|
||||
// In Export for Screens too, in a row or in the format's settings.
|
||||
let row = json!({"formats": [{"format": "webp", "lossless": false, "quality": q}]});
|
||||
assert!(s.execute("document.exportForScreens", &row).is_err(), "{q}");
|
||||
let settings = json!({"formats": [{"format": "webp"}], "settings": {"webp": {"lossless": false, "quality": q}}});
|
||||
assert!(s.execute("document.exportForScreens", &settings).is_err(), "{q}");
|
||||
}
|
||||
// A lossless file refuses it as well: the value is not a WebP quality.
|
||||
assert!(s.execute("document.export", &json!({"format": "webp", "quality": 101})).is_err());
|
||||
let r = s.execute("document.exportForScreens", &json!({"formats": [{"format": "webp", "lossless": false, "quality": 100}]})).unwrap();
|
||||
let file = b64(&r["files"][0]);
|
||||
assert_eq!(webp_chunks(&file), [*b"VP8 "]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -5,8 +5,8 @@ use super::compose::{Builder, CLEAR, Composer, Elem, Fill, Kind, Px, WHITE};
|
||||
use super::options::FlattenOptions;
|
||||
use super::{
|
||||
Affine, Appearance, AppearanceItem, Arc, BlendMode, Color, ColorMode, Document, EngineError, FillLayer, FillRule, ImageBlob, ImageObject, Inks,
|
||||
MAX_PIXELS, Node, NodeId, NodeKind, Paint, PathData, Rect, Result, composite, effects, isolated_doc, leaves, outline_strokes, planes_cmyk, po,
|
||||
separate, shape_node, shapes, unique_key,
|
||||
Knockout, MAX_PIXELS, Node, NodeId, NodeKind, Paint, PathData, Rect, Result, composite, effects, isolated_doc, leaves, outline_strokes,
|
||||
planes_cmyk, po, separate, shape_node, shapes, unique_key,
|
||||
};
|
||||
|
||||
// ---------- plan ----------
|
||||
@@ -756,27 +756,140 @@ pub(crate) fn flatten_document(doc: &Document, o: &FlattenOptions) -> Result<Opt
|
||||
Ok(flatten_expanded(expanded.as_ref().unwrap_or(doc), o)?.or(expanded))
|
||||
}
|
||||
|
||||
fn has_layer_container_transparency(n: &Node) -> bool {
|
||||
!n.has_default_transparency() || n.children().into_iter().flatten().any(|c| c.is_layer() && has_layer_container_transparency(c))
|
||||
}
|
||||
|
||||
/// [`flatten_document`] for `doc` whose pattern tile images were expanded already
|
||||
/// ([`expand_transparent_tile_images`]).
|
||||
pub(crate) fn flatten_expanded(doc: &Document, o: &FlattenOptions) -> Result<Option<Document>> {
|
||||
let outlining = o.text_to_outlines || o.strokes_to_outlines || !o.preserve_overprints;
|
||||
if !outlining && !doc.layers.iter().any(|l| o.shows_transparency(doc, l) || o.draws_see_through_image(l)) {
|
||||
return Ok(None);
|
||||
}
|
||||
let mut roots = vec![];
|
||||
for l in doc.layers.iter().filter(|l| l.visible && !matches!(l.kind, NodeKind::Layer { template: true, .. })) {
|
||||
let children = l.children().map_or(&[][..], Vec::as_slice);
|
||||
roots.extend(children.iter().skip(usize::from(l.clips())).filter(|c| c.visible && !c.is_ruler_guide()).map(|c| c.id));
|
||||
}
|
||||
let plan = plan(doc, &roots, o, true)?;
|
||||
if plan.flat.is_empty() && !plan.work.iter().any(|k| k.changes) {
|
||||
let needs_flatten = outlining
|
||||
|| doc.layers.iter().any(|l| {
|
||||
(o.no_transparency.is_some() && has_layer_container_transparency(l)) || o.shows_transparency(doc, l) || o.draws_see_through_image(l)
|
||||
});
|
||||
if !needs_flatten {
|
||||
return Ok(None);
|
||||
}
|
||||
let mut d = doc.clone();
|
||||
let changed = o.no_transparency.is_some() && normalize_layer_transparency(&mut d, o);
|
||||
let mut roots = vec![];
|
||||
for l in d.layers.iter().filter(|l| l.visible && !matches!(l.kind, NodeKind::Layer { template: true, .. })) {
|
||||
let children = l.children().map_or(&[][..], Vec::as_slice);
|
||||
roots.extend(children.iter().skip(usize::from(l.clips())).filter(|c| c.visible && !c.is_ruler_guide()).map(|c| c.id));
|
||||
}
|
||||
let plan = plan(&d, &roots, o, true)?;
|
||||
if plan.flat.is_empty() && !plan.work.iter().any(|k| k.changes) {
|
||||
if changed {
|
||||
if o.no_transparency.is_some() {
|
||||
for l in &mut d.layers {
|
||||
sanitize_container_transparency(Arc::make_mut(l));
|
||||
}
|
||||
}
|
||||
return Ok(Some(d));
|
||||
}
|
||||
return Ok(None);
|
||||
}
|
||||
apply(&mut d, &mut vectorcraft_doc::Selection::default(), plan, o)?;
|
||||
if o.no_transparency.is_some() {
|
||||
for l in &mut d.layers {
|
||||
sanitize_container_transparency(Arc::make_mut(l));
|
||||
}
|
||||
}
|
||||
Ok(Some(d))
|
||||
}
|
||||
|
||||
/// Flatten and normalize container-level transparency (on layers and sublayers) into groups
|
||||
/// so that the flattener's plan includes them and leaves no container transparency behind.
|
||||
fn normalize_layer_transparency(d: &mut Document, o: &FlattenOptions) -> bool {
|
||||
if o.no_transparency.is_none() {
|
||||
return false;
|
||||
}
|
||||
let mut changed = false;
|
||||
let mut layers = std::mem::take(&mut d.layers);
|
||||
for l in &mut layers {
|
||||
changed |= normalize_node_transparency(d, Arc::make_mut(l));
|
||||
}
|
||||
d.layers = layers;
|
||||
changed
|
||||
}
|
||||
|
||||
fn clear_transparency(n: &mut Node) {
|
||||
n.opacity = 1.0;
|
||||
n.blend = BlendMode::Normal;
|
||||
n.isolate = false;
|
||||
n.knockout = Knockout::Neutral;
|
||||
n.knockout_shape = false;
|
||||
n.extras_mut().mask = None;
|
||||
n.appearance = Appearance::default().into();
|
||||
}
|
||||
|
||||
fn normalize_node_transparency(d: &mut Document, n: &mut Node) -> bool {
|
||||
let mut changed = false;
|
||||
let is_layer = n.is_layer();
|
||||
let clips = n.clips();
|
||||
|
||||
if let Some(children) = n.children_mut() {
|
||||
for c in children.iter_mut() {
|
||||
if c.is_layer() {
|
||||
changed |= normalize_node_transparency(d, Arc::make_mut(c));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let has_transparency = !n.has_default_transparency() || n.shows_own_transparency();
|
||||
|
||||
if is_layer && has_transparency {
|
||||
let children = n.children().map_or(&[][..], Vec::as_slice);
|
||||
let (guides, art): (Vec<_>, Vec<_>) = children.iter().cloned().partition(|c| c.is_ruler_guide());
|
||||
|
||||
if art.is_empty() {
|
||||
clear_transparency(n);
|
||||
n.set_clips(false);
|
||||
changed = true;
|
||||
} else {
|
||||
let mut g = Node::group(d.alloc_id(), art);
|
||||
if clips {
|
||||
g.set_clips(true);
|
||||
}
|
||||
g.opacity = n.opacity;
|
||||
g.blend = n.blend;
|
||||
g.isolate = n.isolate;
|
||||
g.knockout = n.knockout;
|
||||
g.knockout_shape = n.knockout_shape;
|
||||
g.appearance = n.appearance.clone();
|
||||
g.extras_mut().mask = n.extras_mut().mask.take();
|
||||
|
||||
n.set_clips(false);
|
||||
clear_transparency(n);
|
||||
|
||||
let mut new_children = vec![Arc::new(g)];
|
||||
new_children.extend(guides);
|
||||
if let Some(ch) = n.children_mut() {
|
||||
*ch = new_children;
|
||||
}
|
||||
changed = true;
|
||||
}
|
||||
} else if is_layer && !n.visible {
|
||||
clear_transparency(n);
|
||||
}
|
||||
|
||||
changed
|
||||
}
|
||||
|
||||
fn sanitize_container_transparency(n: &mut Node) {
|
||||
if n.is_container() {
|
||||
clear_transparency(n);
|
||||
if let Some(children) = n.children_mut() {
|
||||
for c in children.iter_mut() {
|
||||
if c.is_container() {
|
||||
sanitize_container_transparency(Arc::make_mut(c));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- apply ----------
|
||||
|
||||
pub(super) fn apply(d: &mut Document, sel: &mut vectorcraft_doc::Selection, plan: Plan, o: &FlattenOptions) -> Result<(Vec<NodeId>, usize, usize)> {
|
||||
|
||||
@@ -247,10 +247,11 @@ impl Resources {
|
||||
fn expand(&mut self, d: &Document) {
|
||||
let mut symbols: Vec<String> = self.symbols.iter().cloned().collect();
|
||||
let mut patterns: Vec<String> = self.patterns.iter().cloned().collect();
|
||||
let boxes = d.symbol_boxes();
|
||||
while !symbols.is_empty() || !patterns.is_empty() {
|
||||
let mut more = Resources::default();
|
||||
for name in symbols.drain(..) {
|
||||
if let Some(sym) = d.symbols.iter().find(|sym| sym.name == name) {
|
||||
if let Some(sym) = boxes.symbol(&name) {
|
||||
more.add(&sym.art);
|
||||
}
|
||||
}
|
||||
@@ -511,7 +512,7 @@ pub(super) fn art_fonts(d: &Document, art: &[Node]) -> BTreeSet<UsedFont> {
|
||||
/// art of a placed document (`d` as [`Document::with_placed_art`] gives it, for that art's
|
||||
/// resources).
|
||||
pub(super) fn printed_type(d: &Document, layers: &[Arc<Node>], areas: &[Rect]) -> (BTreeSet<UsedFont>, BTreeSet<NodeId>) {
|
||||
let mut walk = Printed { d, own: true, fonts: BTreeSet::new(), overflow: BTreeSet::new(), symbols: BTreeSet::new(), patterns: BTreeSet::new() };
|
||||
let mut walk = Printed::new(d);
|
||||
for l in layers {
|
||||
walk.node(l, Some(areas));
|
||||
}
|
||||
@@ -523,7 +524,7 @@ pub(super) fn printed_type(d: &Document, layers: &[Arc<Node>], areas: &[Rect]) -
|
||||
/// found as [`printed_type`] finds them for Print: visible objects of the document that aren't on
|
||||
/// a template layer.
|
||||
pub(super) fn export_overflow_warning(d: &Document, layers: &[Arc<Node>], areas: Option<&[Rect]>) -> Option<String> {
|
||||
let mut walk = Printed { d, own: true, fonts: BTreeSet::new(), overflow: BTreeSet::new(), symbols: BTreeSet::new(), patterns: BTreeSet::new() };
|
||||
let mut walk = Printed::new(d);
|
||||
for l in layers {
|
||||
walk.node(l, areas);
|
||||
}
|
||||
@@ -534,6 +535,9 @@ pub(super) fn export_overflow_warning(d: &Document, layers: &[Arc<Node>], areas:
|
||||
/// The walk of [`printed_type`].
|
||||
struct Printed<'a> {
|
||||
d: &'a Document,
|
||||
/// `d`'s symbols, found by name. Each object is measured in boxes of its own made from these
|
||||
/// ([`vectorcraft_doc::SymbolBoxes::unmeasured`]).
|
||||
boxes: vectorcraft_doc::SymbolBoxes<'a>,
|
||||
/// Whether the walk is among the objects of the document, not in art drawn for one.
|
||||
own: bool,
|
||||
fonts: BTreeSet<UsedFont>,
|
||||
@@ -544,7 +548,13 @@ struct Printed<'a> {
|
||||
patterns: BTreeSet<String>,
|
||||
}
|
||||
|
||||
impl Printed<'_> {
|
||||
impl<'a> Printed<'a> {
|
||||
/// A walk of `d` among its own objects, nothing found yet.
|
||||
fn new(d: &'a Document) -> Self {
|
||||
let boxes = d.symbol_boxes();
|
||||
Self { d, boxes, own: true, fonts: BTreeSet::new(), overflow: BTreeSet::new(), symbols: BTreeSet::new(), patterns: BTreeSet::new() }
|
||||
}
|
||||
|
||||
/// Adds the fonts of `n` and its descendants that print, and the ids of those that don't fit
|
||||
/// while [`Printed::own`] is set: those whose bounds meet one of `areas`, or with `None` (in the
|
||||
/// art of a symbol, opacity mask, pattern or placed document, in brush pieces, or in a live
|
||||
@@ -625,7 +635,7 @@ impl Printed<'_> {
|
||||
let clipped = match (clip, areas) {
|
||||
(false, _) => None,
|
||||
(true, Some(a)) => Some(self.clip(n, a)),
|
||||
(true, None) => vectorcraft_render::painted_bounds(self.d, n).map(|c| vec![c]),
|
||||
(true, None) => vectorcraft_render::painted_bounds_with(&self.boxes.unmeasured(), n).map(|c| vec![c]),
|
||||
};
|
||||
for c in children {
|
||||
self.node(c, clipped.as_deref().or(areas));
|
||||
@@ -641,9 +651,8 @@ impl Printed<'_> {
|
||||
|
||||
/// Adds the fonts of symbol `name`'s art, the first time it is shown.
|
||||
fn symbol(&mut self, name: &str) {
|
||||
let d = self.d;
|
||||
if self.symbols.insert(name.to_string())
|
||||
&& let Some(s) = d.symbols.iter().find(|s| s.name == name)
|
||||
&& let Some(s) = self.boxes.symbol(name)
|
||||
{
|
||||
self.art(&s.art);
|
||||
}
|
||||
@@ -660,12 +669,13 @@ impl Printed<'_> {
|
||||
|
||||
/// Whether what `n` paints, its effects applied, meets one of `areas`.
|
||||
fn meets(&self, n: &Node, areas: &[Rect]) -> bool {
|
||||
vectorcraft_render::painted_bounds(self.d, n).is_some_and(|b| areas.iter().any(|r| b.intersect(*r).area() > 0.0 || r.contains_rect(b)))
|
||||
vectorcraft_render::painted_bounds_with(&self.boxes.unmeasured(), n)
|
||||
.is_some_and(|b| areas.iter().any(|r| b.intersect(*r).area() > 0.0 || r.contains_rect(b)))
|
||||
}
|
||||
|
||||
/// The parts of `areas` inside the bounds of clip group `n` (its clipping path's).
|
||||
fn clip(&self, n: &Node, areas: &[Rect]) -> Vec<Rect> {
|
||||
let Some(c) = vectorcraft_render::painted_bounds(self.d, n) else { return areas.to_vec() };
|
||||
let Some(c) = vectorcraft_render::painted_bounds_with(&self.boxes.unmeasured(), n) else { return areas.to_vec() };
|
||||
areas.iter().filter(|r| c.intersect(**r).area() > 0.0 || r.contains_rect(c)).map(|r| r.intersect(c)).collect()
|
||||
}
|
||||
}
|
||||
@@ -2378,4 +2388,40 @@ mod dirty_tests {
|
||||
s.execute("edit.undo", &json!({})).unwrap();
|
||||
assert!(!s.doc().unwrap().is_dirty(), "back to the saved state");
|
||||
}
|
||||
|
||||
/// The walk Print and the exports make over 300 instances with drop shadows, among 2,000
|
||||
/// symbols, reads the symbol list once to find their symbols.
|
||||
#[test]
|
||||
fn printed_type_reads_the_symbol_list_once() {
|
||||
let mut d = Document::new(200.0, 200.0);
|
||||
for i in 0..2000 {
|
||||
let art = Node::path(
|
||||
d.alloc_id(),
|
||||
vectorcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, 1.0, 1.0)),
|
||||
vectorcraft_doc::Appearance::basic(Paint::None, Paint::None, 0.0),
|
||||
);
|
||||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: format!("Filler {i}"), art: Arc::new(art) });
|
||||
}
|
||||
let art = Node::path(
|
||||
d.alloc_id(),
|
||||
vectorcraft_geom::shapes::rectangle(Rect::new(-10.0, -10.0, 10.0, 10.0)),
|
||||
vectorcraft_doc::Appearance::basic(Paint::solid(vectorcraft_color::Color::BLACK), Paint::None, 0.0),
|
||||
);
|
||||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Mark".into(), art: Arc::new(art) });
|
||||
let l = d.layers[0].id;
|
||||
for i in 0..300 {
|
||||
let xf = vectorcraft_geom::Affine::translate((f64::from(i % 20) * 10.0, f64::from(i / 20) * 10.0));
|
||||
let mut n = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Mark".into(), xf });
|
||||
n.appearance.effects.push(vectorcraft_doc::Effect {
|
||||
id: "stylize.dropShadow".into(),
|
||||
params: json!({"x": 1, "y": 1, "blur": 0}),
|
||||
visible: true,
|
||||
});
|
||||
d.insert(Some(l), usize::MAX, n).unwrap();
|
||||
}
|
||||
let before = vectorcraft_doc::symbols_read();
|
||||
printed_type(&d, &d.layers, &[Rect::new(0.0, 0.0, 100.0, 100.0)]);
|
||||
let read = vectorcraft_doc::symbols_read() - before;
|
||||
assert!(read <= d.symbols.len(), "{read} symbols read, {} in the document", d.symbols.len());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -26,7 +26,9 @@ use serde_json::{Value, json};
|
||||
use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
|
||||
use vectorcraft_geom::{FillRule, PathData, Point, SubPath};
|
||||
use vectorcraft_pathops as po;
|
||||
use vectorcraft_tools::intertwine::{Face, drawn_order, face_at, faces_in, faces_of, is_intertwine, nonempty, painted_areas};
|
||||
use vectorcraft_tools::intertwine::{
|
||||
Face, drawn_order, face_at, faces_in, faces_of, in_intertwine, is_intertwine, nonempty, painted_areas, refused_member,
|
||||
};
|
||||
|
||||
use super::edit::selected_roots;
|
||||
use super::pathops::Beside;
|
||||
@@ -106,17 +108,7 @@ fn refused(d: &Document, n: &Node) -> Option<&'static str> {
|
||||
if around.iter().filter(|a| **a != n.id).filter_map(|a| d.node(*a)).any(is_intertwine) {
|
||||
return Some("an object already in an Intertwine group");
|
||||
}
|
||||
let mut why = None;
|
||||
n.walk(&mut |c| {
|
||||
why = why.or(match &c.kind {
|
||||
NodeKind::Intertwine { .. } => Some("an Intertwine group"),
|
||||
NodeKind::Repeat(_) => Some("a Repeat"),
|
||||
NodeKind::Group { .. } if c.extras().graph.is_some() => Some("a graph"),
|
||||
NodeKind::Group { .. } if vectorcraft_tools::builder::is_live_paint(c) => Some("a Live Paint group"),
|
||||
_ => None,
|
||||
});
|
||||
});
|
||||
why
|
||||
refused_member(n)
|
||||
}
|
||||
|
||||
fn make(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
@@ -179,10 +171,7 @@ fn release(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
.flatten()
|
||||
.map(|c| {
|
||||
let mut c = (**c).clone();
|
||||
let mut e = c.extras_mut();
|
||||
e.intertwine = None;
|
||||
e.intertwine_tiers = Vec::new();
|
||||
drop(e);
|
||||
without_areas(&mut c);
|
||||
c
|
||||
})
|
||||
.collect();
|
||||
@@ -196,6 +185,92 @@ fn release(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
Ok(json!({ "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>() }))
|
||||
}
|
||||
|
||||
// ---------- members that come and go ----------
|
||||
|
||||
/// Why `n` can't go into `parent`, an Intertwine group or a container inside one, if it can't
|
||||
/// ([`refused_member`]). Other containers take it as they did.
|
||||
pub(crate) fn refused_in(d: &Document, parent: Option<NodeId>, n: &Node) -> Option<&'static str> {
|
||||
parent.filter(|p| in_intertwine(d, *p)).and_then(|_| refused_member(n))
|
||||
}
|
||||
|
||||
/// The Intertwine groups that `ids` are members of, each once.
|
||||
pub(crate) fn groups_of(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
ids.iter().filter_map(|i| d.parent_of(*i)).filter(|g| d.node(*g).is_some_and(is_intertwine) && seen.insert(*g)).collect()
|
||||
}
|
||||
|
||||
/// `n` without the areas it is drawn over other members in.
|
||||
fn without_areas(n: &mut Node) {
|
||||
if n.extras().intertwine.is_some() || !n.extras().intertwine_tiers.is_empty() {
|
||||
let mut e = n.extras_mut();
|
||||
e.intertwine = None;
|
||||
e.intertwine_tiers = Vec::new();
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether Intertwine group `g` has nothing of its own that changes how its members are drawn:
|
||||
/// it is visible and unlocked, with full opacity, normal blending, no appearance and no extras
|
||||
/// (an opacity mask among them).
|
||||
fn bare(g: &Node) -> bool {
|
||||
let plain = Node::new(g.id, NodeKind::Intertwine { children: vec![] });
|
||||
(g.visible, g.locked, g.opacity, g.blend, g.isolate, g.knockout, g.knockout_shape)
|
||||
== (plain.visible, plain.locked, plain.opacity, plain.blend, plain.isolate, plain.knockout, plain.knockout_shape)
|
||||
&& g.appearance == plain.appearance
|
||||
&& *g.extras() == *plain.extras()
|
||||
}
|
||||
|
||||
/// After objects moved in the Layers panel: each of `placed` (the objects now in place, each with
|
||||
/// the container it came from, None for a copy) that is not in the container it came from loses
|
||||
/// the areas it was drawn over other members in, so it joins an Intertwine group at no tier and
|
||||
/// leaves one as ordinary art. Then each of `left` (the Intertwine groups objects came from) that
|
||||
/// has fewer than two members is taken apart: its one member goes in its place without areas, and
|
||||
/// an empty one is removed. A group with one member and something of its own ([`bare`]) becomes a
|
||||
/// plain group of that member instead, keeping its id and all it has. The other members keep their
|
||||
/// areas.
|
||||
pub(crate) fn settle_members(d: &mut Document, placed: &[(NodeId, Option<NodeId>)], left: &[NodeId]) -> Result<()> {
|
||||
for (id, from) in placed {
|
||||
if d.node(*id).is_some_and(|n| n.extras().intertwine.is_some() || !n.extras().intertwine_tiers.is_empty())
|
||||
&& from.is_none_or(|f| d.parent_of(*id) != Some(f))
|
||||
{
|
||||
without_areas(d.node_mut(*id).ok_or(EngineError::NoNode(*id))?);
|
||||
}
|
||||
}
|
||||
let lone: Vec<NodeId> =
|
||||
left.iter().copied().filter(|g| d.node(*g).is_some_and(|n| is_intertwine(n) && n.children().is_none_or(|c| c.len() < 2))).collect();
|
||||
let (kept, lone): (Vec<NodeId>, Vec<NodeId>) =
|
||||
lone.into_iter().partition(|g| d.node(*g).is_some_and(|n| n.children().is_some_and(|c| c.len() == 1) && !bare(n)));
|
||||
for g in &kept {
|
||||
let n = d.node_mut(*g).ok_or(EngineError::NoNode(*g))?;
|
||||
if let NodeKind::Intertwine { children } = &mut n.kind {
|
||||
let children = std::mem::take(children)
|
||||
.into_iter()
|
||||
.map(|c| {
|
||||
let mut c = (*c).clone();
|
||||
without_areas(&mut c);
|
||||
Arc::new(c)
|
||||
})
|
||||
.collect();
|
||||
n.kind = NodeKind::Group { children, clip: false };
|
||||
}
|
||||
}
|
||||
let mut apart = Beside::replacing(d, &lone);
|
||||
for g in &lone {
|
||||
let Some(n) = d.node(*g) else { continue };
|
||||
let members: Vec<Node> = n
|
||||
.children()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(|c| {
|
||||
let mut c = (**c).clone();
|
||||
without_areas(&mut c);
|
||||
c
|
||||
})
|
||||
.collect();
|
||||
apart.put(d, *g, members)?;
|
||||
}
|
||||
apart.finish(d)
|
||||
}
|
||||
|
||||
// ---------- Expand ----------
|
||||
|
||||
/// Replace Intertwine group `id` by a plain group of the art it draws
|
||||
|
||||
@@ -110,7 +110,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Move Rows",
|
||||
[],
|
||||
None,
|
||||
"{ids|id, target, place?: \"above\"|\"below\"|\"inside\" (default inside), copy?: bool} drag rows in the Layers panel: above or below the target row (beside it, in its layer or group), or inside a layer or group (on top of its contents). Layers go only in layers or at the top level, objects in layers and groups; an object placed beside a top-level layer goes inside it. A row never goes into itself; a locked layer or group takes nothing. `copy` (Alt-drag) moves copies. Every selected object left hidden or locked, such as one moved into a hidden layer or group, is deselected (the key object too). One undo step → {ids}",
|
||||
"{ids|id, target, place?: \"above\"|\"below\"|\"inside\" (default inside), copy?: bool} drag rows in the Layers panel: above or below the target row (beside it, in its layer or group), or inside a layer, group or Intertwine group (on top of its contents). Layers go only in layers or at the top level, objects in layers, groups and Intertwine groups; an object placed beside a top-level layer goes inside it. An object placed in an Intertwine group becomes a member drawn in its row's order, with no arranged areas, and one placed in a group that is a member becomes part of that member; one that is or holds an Intertwine group, a Repeat, a graph or a Live Paint group is refused. A member moved out of its Intertwine group drops its arranged areas, and a group left with one member is replaced by that member, or becomes a plain group of it when the group has an opacity, blending, appearance, mask, lock or hidden state of its own (with no member, it is removed). A row never goes into itself; a locked layer or group takes nothing. `copy` (Alt-drag) moves copies. Every selected object left hidden or locked, such as one moved into a hidden layer or group, is deselected (the key object too). One undo step → {ids}",
|
||||
has_doc,
|
||||
move_rows
|
||||
),
|
||||
@@ -119,7 +119,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Reorder",
|
||||
[],
|
||||
None,
|
||||
"{id, parent?: id (null = top level), index} put a row at `index` (0 = bottom) of `parent` (layers only at the top level or in layers), deselecting every selected object left hidden or locked (the key object too)",
|
||||
"{id, parent?: id (null = top level), index} put a row at `index` (0 = bottom) of `parent` (layers only at the top level or in layers; an Intertwine group takes and gives up members as layer.move does), deselecting every selected object left hidden or locked (the key object too)",
|
||||
has_doc,
|
||||
move_node
|
||||
),
|
||||
@@ -242,14 +242,15 @@ pub(crate) fn row_roots(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
|
||||
}
|
||||
|
||||
/// Whether `parent` (None: the top level) can hold `n`: layers go at the top level or in layers,
|
||||
/// anything else in layers and groups.
|
||||
/// anything else in layers, groups and Intertwine groups (which also check what the object holds:
|
||||
/// [`super::intertwine::refused_in`]).
|
||||
pub(crate) fn accepts(d: &Document, parent: Option<NodeId>, n: &Node) -> bool {
|
||||
match parent {
|
||||
None => n.is_layer(),
|
||||
Some(p) => match d.node(p).map(|x| &x.kind) {
|
||||
Some(NodeKind::Layer { .. }) => true,
|
||||
// A ruler guide stays directly in a layer or sublayer.
|
||||
Some(NodeKind::Group { .. }) => !n.is_layer() && !n.is_ruler_guide(),
|
||||
Some(NodeKind::Group { .. } | NodeKind::Intertwine { .. }) => !n.is_layer() && !n.is_ruler_guide(),
|
||||
_ => false,
|
||||
},
|
||||
}
|
||||
@@ -790,10 +791,17 @@ fn move_rows(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let into = parent.and_then(|p| d.node(p)).map_or("the top level", |p| if p.is_layer() { "a layer" } else { p.kind_label() });
|
||||
return Err(bad(C, format!("{} can't go into {into}", n.display_name())));
|
||||
}
|
||||
if let Some(what) = nodes.iter().find_map(|n| super::intertwine::refused_in(d, parent, n)) {
|
||||
return Err(bad(C, format!("{what} can't be intertwined")));
|
||||
}
|
||||
if parent.is_some_and(|p| locked_within(d, p)) {
|
||||
return Err(EngineError::Other("the layer or group is locked".into()));
|
||||
}
|
||||
let label = if copy { "Duplicate Rows" } else { "Move Rows" };
|
||||
// Where each moved row comes from (a copy has a new id, so it comes from nowhere), and the
|
||||
// Intertwine groups it leaves.
|
||||
let from: std::collections::HashMap<NodeId, Option<NodeId>> = ids.iter().map(|i| (*i, d.parent_of(*i))).collect();
|
||||
let left = if copy { vec![] } else { super::intertwine::groups_of(d, &ids) };
|
||||
let moved = s.edit(label, |d, sel| {
|
||||
let nodes = if copy {
|
||||
let mut nodes = vec![];
|
||||
@@ -828,6 +836,8 @@ fn move_rows(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if copy {
|
||||
super::typecmd::refresh_bounds_of(d, &out);
|
||||
}
|
||||
let placed: Vec<(NodeId, Option<NodeId>)> = out.iter().map(|o| (*o, from.get(o).copied().flatten())).collect();
|
||||
super::intertwine::settle_members(d, &placed, &left)?;
|
||||
sel.prune(d);
|
||||
sel.deselect_uneditable(d);
|
||||
Ok(out)
|
||||
@@ -847,8 +857,15 @@ fn move_node(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if !accepts(d, parent, n) {
|
||||
return Err(bad(C, "layers go only at the top level or in layers, objects in layers and groups"));
|
||||
}
|
||||
if let Some(what) = super::intertwine::refused_in(d, parent, n) {
|
||||
return Err(bad(C, format!("{what} can't be intertwined")));
|
||||
}
|
||||
let from = d.parent_of(id);
|
||||
let left = super::intertwine::groups_of(d, &[id]);
|
||||
s.edit("Reorder", |d, sel| {
|
||||
d.move_node(id, parent, index)?;
|
||||
super::intertwine::settle_members(d, &[(id, from)], &left)?;
|
||||
sel.prune(d);
|
||||
sel.deselect_uneditable(d);
|
||||
Ok(())
|
||||
})?;
|
||||
|
||||
@@ -713,12 +713,12 @@ type FileClip = (PathData, FillRule);
|
||||
|
||||
/// The clipping path the file of image content `blob` draws it through, in its pixel space, as it
|
||||
/// was kept when the file was read: a DCS file's ([`ImageBlob::separated_clip`]) or a PSD or PSB
|
||||
/// file's ([`fileio::png_clip`]).
|
||||
/// file's ([`fileio::image_clip`]).
|
||||
fn file_clip(blob: &ImageBlob) -> Option<FileClip> {
|
||||
if let Some(path) = blob.separated_clip() {
|
||||
return Some((path, FillRule::NonZero));
|
||||
}
|
||||
(blob.mime == "image/png").then(|| fileio::png_clip(&blob.bytes)).flatten().map(|path| (path, FillRule::EvenOdd))
|
||||
fileio::image_clip(blob).map(|path| (path, FillRule::EvenOdd))
|
||||
}
|
||||
|
||||
/// What happens to the clip of an object a link update remakes.
|
||||
|
||||
@@ -92,7 +92,7 @@ pub(super) fn blend_make(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
_ => defaults,
|
||||
};
|
||||
let spacing = spacing_param(p, C, cur.spacing)?;
|
||||
let orientation = orientation_param(p, cur.orientation);
|
||||
let orientation = orientation_param(p, C, cur.orientation)?;
|
||||
let (ease0, color0, no_spine) = match base.as_ref().map(|n| &n.kind) {
|
||||
Some(NodeKind::Blend { spec, .. }) => (spec.ease, spec.color_shift, spec.no_spine),
|
||||
_ => (Default::default(), 0.0, !create_spine.creates_spine()),
|
||||
@@ -364,29 +364,91 @@ fn selected_spec(s: &Session) -> Option<(NodeId, BlendSpec, Vec<NodeId>)> {
|
||||
|
||||
pub(super) fn blend_options(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
const C: &str = "object.blend.options";
|
||||
let Some((_, cur, _)) = selected_spec(s) else {
|
||||
let id = crate::cmd::object_param(p, "id", C)?;
|
||||
let target = match id {
|
||||
Some(id) => {
|
||||
let doc = &s.doc()?.doc;
|
||||
match doc.node(id).map(|n| &n.kind) {
|
||||
Some(NodeKind::Blend { .. }) if !doc.is_editable(id) => return Err(bad(C, "the object is hidden or locked")),
|
||||
Some(NodeKind::Blend { spec, children }) => Some((id, (**spec).clone(), children.iter().map(|c| c.id).collect())),
|
||||
_ => return Err(bad(C, "not a blend")),
|
||||
}
|
||||
}
|
||||
None => selected_spec(s),
|
||||
};
|
||||
let Some((_, cur, _)) = target else {
|
||||
if ["easingType", "ramp", "colorShift"].iter().any(|key| p.get(*key).is_some_and(|v| !v.is_null())) {
|
||||
return Err(bad(C, "select a blend to set easing or color shift"));
|
||||
}
|
||||
// Nothing to set them on: the options new blends start with (easing is per blend).
|
||||
let d = s.prefs.blend_options.unwrap_or_default();
|
||||
let spacing = spacing_param(p, C, d.spacing)?;
|
||||
s.prefs.blend_options = Some(BlendDefaults { spacing, orientation: orientation_param(p, d.orientation), ..d });
|
||||
let orientation = orientation_param(p, C, d.orientation)?;
|
||||
s.prefs.blend_options = Some(BlendDefaults { spacing, orientation, ..d });
|
||||
return Ok(json!({ "defaults": true }));
|
||||
};
|
||||
if gives_easing(p) && any_without_spine(s) {
|
||||
let no_spine = if id.is_some() { cur.no_spine } else { any_without_spine(s) };
|
||||
if gives_easing(p) && no_spine {
|
||||
return Err(bad(C, "the blend has no spine"));
|
||||
}
|
||||
// Every value is checked before anything changes. Each blend then takes only the values that
|
||||
// were given and keeps its own for the rest, so editing several blends does not copy the first
|
||||
// one's options onto the others.
|
||||
let given = |key: &str| p.get(key).is_some_and(|v| !v.is_null());
|
||||
let has_count = given("value") || given("steps") || given("distance");
|
||||
let has_spacing = given("spacing") || has_count || p.get("smooth").and_then(Value::as_bool) == Some(true);
|
||||
let spacing = spacing_param(p, C, cur.spacing)?;
|
||||
let orientation = orientation_param(p, cur.orientation);
|
||||
let orientation = orientation_param(p, C, cur.orientation)?;
|
||||
let ease = ease_param(p, C, cur.ease)?;
|
||||
let color_shift = percent_param(p, C, "colorShift", cur.color_shift, -100.0)?;
|
||||
edit_blends(s, "Blend Options", |_, spec| {
|
||||
spec.spacing = spacing;
|
||||
spec.orientation = orientation;
|
||||
spec.ease = ease;
|
||||
spec.color_shift = color_shift;
|
||||
})
|
||||
let (has_orientation, has_kind, has_ramp, has_shift) = (given("orientation"), given("easingType"), given("ramp"), given("colorShift"));
|
||||
let set = |spec: &mut BlendSpec| {
|
||||
// A spacing mode without a count keeps the count of a blend already in that mode.
|
||||
let same_mode = std::mem::discriminant(&spacing) == std::mem::discriminant(&spec.spacing);
|
||||
if has_spacing && (has_count || !same_mode) {
|
||||
spec.spacing = spacing;
|
||||
}
|
||||
if has_orientation {
|
||||
spec.orientation = orientation;
|
||||
}
|
||||
if has_kind {
|
||||
spec.ease.kind = ease.kind;
|
||||
}
|
||||
if has_ramp {
|
||||
spec.ease.ramp = ease.ramp;
|
||||
}
|
||||
if has_shift {
|
||||
spec.color_shift = color_shift;
|
||||
}
|
||||
};
|
||||
let targets = match id {
|
||||
Some(id) => vec![id],
|
||||
None => selected_of(s, is_blend),
|
||||
};
|
||||
let doc = &s.doc()?.doc;
|
||||
let changes = |b: &NodeId| match doc.node(*b).map(|n| &n.kind) {
|
||||
Some(NodeKind::Blend { spec, .. }) => {
|
||||
let mut next = (**spec).clone();
|
||||
set(&mut next);
|
||||
next != **spec
|
||||
}
|
||||
_ => false,
|
||||
};
|
||||
if !targets.iter().any(changes) {
|
||||
return ok();
|
||||
}
|
||||
match id {
|
||||
Some(id) => {
|
||||
s.edit("Blend Options", |d, _| {
|
||||
if let Some(NodeKind::Blend { spec, .. }) = d.node_mut(id).map(|n| &mut n.kind) {
|
||||
set(spec);
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
ok()
|
||||
}
|
||||
None => edit_blends(s, "Blend Options", |_, spec| set(spec)),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn blend_set_easing(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
|
||||
@@ -36,7 +36,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Blend Options…",
|
||||
["Object", "Blend"],
|
||||
None,
|
||||
"{spacing?: smooth|steps|distance, value?: n, steps?: n, distance?: pt, orientation?: page|path, smooth?: bool, easingType?: easeIn|easeOut|easeInOut|easeOutIn, ramp?: pct, colorShift?: pct} set the options of the selected blends; easingType chooses the distribution, ramp sets its strength (0..100; 0 = even), colorShift (-100..100; 0 = even) shifts colours independently of shape/position easing (omitted ones keep their value; out of range is an error); with no blend selected, the options new blends start with (spacing and orientation only; a tool setting, not an undo step) → {defaults?: true}",
|
||||
"{id?: id, spacing?: smooth|steps|distance, value?: n, steps?: n, distance?: pt, orientation?: page|path, smooth?: bool, easingType?: easeIn|easeOut|easeInOut|easeOutIn, ramp?: pct, colorShift?: pct} set the options of the selected blends (or of the blend `id` alone; a hidden or locked one is an error); easingType chooses the distribution, ramp sets its strength (0..100; 0 = even), colorShift (-100..100; 0 = even) shifts colours independently of shape/position easing (each blend keeps its own value for every option omitted; out of range is an error and changes nothing; no undo step when nothing changes); with no blend selected and no `id`, the options new blends start with (spacing and orientation only; a tool setting, not an undo step) → {defaults?: true}",
|
||||
always,
|
||||
blend_options
|
||||
),
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
use super::mesh::whole;
|
||||
use super::{
|
||||
Arc, BlendEase, BlendEaseType, BlendOrientation, BlendSpacing, Document, EngineError, Node, NodeId, NodeKind, Result, Selection, Session, Value,
|
||||
bad, check_numbers, has_selection, json, named_ids, selected_roots, str_param, switch_or,
|
||||
bad, check_numbers, has_selection, json, named_ids, selected_roots, switch_or, text_param,
|
||||
};
|
||||
|
||||
pub(super) fn ids_json(ids: &[NodeId]) -> Value {
|
||||
@@ -128,8 +128,11 @@ pub(super) fn spacing_param(p: &Value, cmd: &str, current: BlendSpacing) -> Resu
|
||||
let smooth = switch_or(p, "smooth", false, cmd)?;
|
||||
let num = |k: &str| p.get(k).and_then(Value::as_f64);
|
||||
let steps = |k: &str, n: f64| whole(n, k, cmd).map(|n| BlendSpacing::Steps(n as u32));
|
||||
let mode = str_param(p, "spacing");
|
||||
let mode = text_param(p, "spacing", cmd)?;
|
||||
let value = num("value");
|
||||
if mode.is_none() && value.is_some() {
|
||||
return Err(bad(cmd, "`value` needs `spacing` (steps|distance)"));
|
||||
}
|
||||
let sp = match mode {
|
||||
Some("smooth") | Some("smoothColor") => BlendSpacing::SmoothColor,
|
||||
Some("steps") => match value {
|
||||
@@ -157,11 +160,15 @@ pub(super) fn spacing_param(p: &Value, cmd: &str, current: BlendSpacing) -> Resu
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn orientation_param(p: &Value, current: BlendOrientation) -> BlendOrientation {
|
||||
match str_param(p, "orientation") {
|
||||
Some("path") | Some("alignToPath") => BlendOrientation::AlignToPath,
|
||||
Some("page") | Some("alignToPage") => BlendOrientation::AlignToPage,
|
||||
_ => current,
|
||||
/// `orientation`: `page` or `path`; missing or null keeps `current`, and any other value is an error.
|
||||
pub(super) fn orientation_param(p: &Value, cmd: &str, current: BlendOrientation) -> Result<BlendOrientation> {
|
||||
match p.get("orientation").filter(|v| !v.is_null()) {
|
||||
None => Ok(current),
|
||||
Some(v) => match v.as_str() {
|
||||
Some("path") | Some("alignToPath") => Ok(BlendOrientation::AlignToPath),
|
||||
Some("page") | Some("alignToPage") => Ok(BlendOrientation::AlignToPage),
|
||||
_ => Err(bad(cmd, "orientation must be page or path")),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -80,11 +80,16 @@ pub(super) fn send_to_current_layer(s: &mut Session, _: &Value) -> Result<Value>
|
||||
if st.doc.children(Some(layer)).is_some_and(|c| c.iter().rev().filter(art).map(|n| n.id).take(ids.len()).eq(ids.iter().rev().copied())) {
|
||||
return ok();
|
||||
}
|
||||
s.edit("Send to Current Layer", |d, _| {
|
||||
let placed: Vec<(NodeId, Option<NodeId>)> = ids.iter().map(|i| (*i, st.doc.parent_of(*i))).collect();
|
||||
let left = crate::cmd::intertwine::groups_of(&st.doc, &ids);
|
||||
s.edit("Send to Current Layer", |d, sel| {
|
||||
let moved = d.remove_many(&ids)?;
|
||||
let ch = d.children_mut(Some(layer))?;
|
||||
let at = Node::guide_run_start(ch);
|
||||
ch.splice(at..at, moved);
|
||||
// Members sent out of an Intertwine group leave it as ordinary art.
|
||||
crate::cmd::intertwine::settle_members(d, &placed, &left)?;
|
||||
sel.prune(d);
|
||||
Ok(())
|
||||
})?;
|
||||
ok()
|
||||
@@ -352,6 +357,7 @@ pub(super) fn isolate(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
&& prev != isolation
|
||||
{
|
||||
crate::cmd::settle_interaction(s)?;
|
||||
add_drawn_live_paint(s, prev, Some(isolation))?;
|
||||
let st = s.doc_mut()?;
|
||||
crate::cmd::distortcmds::finish_edit_text(st, prev);
|
||||
}
|
||||
@@ -364,6 +370,19 @@ pub(super) fn isolate(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
ok()
|
||||
}
|
||||
|
||||
/// Leaving isolation mode in `isolated` for `next` (None: out of isolation mode) adds the paths drawn
|
||||
/// in the Live Paint group isolation put new art in to that group, as `livePaint.merge` does, in one
|
||||
/// undo step ([`crate::cmd::buildcmds::merge_drawn_in_isolation`]), unless `next` is that group or is
|
||||
/// inside it; → the group when paths were added.
|
||||
fn add_drawn_live_paint(s: &mut Session, isolated: NodeId, next: Option<NodeId>) -> Result<Option<NodeId>> {
|
||||
let d = &s.doc()?.doc;
|
||||
let Some(g) = crate::cmd::buildcmds::isolated_live_paint(d, isolated) else { return Ok(None) };
|
||||
if next.is_some_and(|n| d.ancestry(n).is_some_and(|a| a.contains(&g))) {
|
||||
return Ok(None);
|
||||
}
|
||||
Ok(crate::cmd::buildcmds::merge_drawn_in_isolation(s, g)?.then_some(g))
|
||||
}
|
||||
|
||||
pub(super) fn exit_isolation(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
// Opacity mask editing, pattern editing and symbol editing isolate their editing layer. Leaving
|
||||
// isolation mode then leaves that mode, as Stop Editing Opacity Mask and the isolation bar's
|
||||
@@ -373,10 +392,11 @@ pub(super) fn exit_isolation(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
&& let Some(inner) = st.isolation.filter(|i| *i != layer && st.doc.ancestry(*i).is_some_and(|a| a.contains(&layer)))
|
||||
{
|
||||
crate::cmd::settle_interaction(s)?;
|
||||
let left = add_drawn_live_paint(s, inner, Some(layer))?.unwrap_or(inner);
|
||||
let st = s.doc_mut()?;
|
||||
crate::cmd::distortcmds::finish_edit_text(st, inner);
|
||||
st.isolation = Some(layer);
|
||||
st.selection.set([inner]);
|
||||
st.selection.set([left]);
|
||||
st.revision += 1;
|
||||
return ok();
|
||||
}
|
||||
@@ -391,6 +411,8 @@ pub(super) fn exit_isolation(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
};
|
||||
if let Some(leave_mode) = leave_mode {
|
||||
if let Some(i) = st.isolation {
|
||||
crate::cmd::settle_interaction(s)?;
|
||||
add_drawn_live_paint(s, i, None)?;
|
||||
crate::cmd::distortcmds::finish_edit_text(s.doc_mut()?, i);
|
||||
}
|
||||
leave_mode(s, p)?;
|
||||
@@ -400,10 +422,11 @@ pub(super) fn exit_isolation(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let prev = s.active().and_then(|d| d.isolation);
|
||||
if let Some(i) = prev {
|
||||
crate::cmd::settle_interaction(s)?;
|
||||
let left = add_drawn_live_paint(s, i, None)?.unwrap_or(i);
|
||||
let st = s.doc_mut()?;
|
||||
st.isolation = None;
|
||||
crate::cmd::distortcmds::finish_edit_text(st, i);
|
||||
let target = st.doc.parent_of(i).filter(|p| st.doc.node(*p).is_some_and(|n| n.extras().shaper.is_some())).unwrap_or(i);
|
||||
let target = st.doc.parent_of(left).filter(|p| st.doc.node(*p).is_some_and(|n| n.extras().shaper.is_some())).unwrap_or(left);
|
||||
st.selection.set([target]);
|
||||
// A guide path isolated while Lock Guides is on isn't selected (#1534).
|
||||
crate::deselect_hidden(&menu, &st.doc, &mut st.selection);
|
||||
|
||||
@@ -56,6 +56,7 @@ pub(crate) fn object_bounds_transform(s: &Session, p: &Value, id: NodeId) -> Res
|
||||
/// direct-selected anchors are what changes ([`Bounds::Anchors`]).
|
||||
fn bounds_transform(s: &Session, p: &Value, ids: Vec<NodeId>, least: f64, anchors: bool) -> Result<Bounds> {
|
||||
check_numbers(p, &["x", "y", "width", "height", "reference"], "object.setBounds")?;
|
||||
let refi = reference_index(p)?;
|
||||
let st = s.doc()?;
|
||||
check_switches(p, &TRANSFORM_SWITCHES, "object.setBounds")?;
|
||||
check_switches(p, &["proportional"], "object.setBounds")?;
|
||||
@@ -90,7 +91,6 @@ fn bounds_transform(s: &Session, p: &Value, ids: Vec<NodeId>, least: f64, anchor
|
||||
let margins = |b: Rect| [g.x0 - b.x0, g.y0 - b.y0, b.x1 - g.x1, b.y1 - g.y1];
|
||||
let (m, all) = (margins(vs), margins(v));
|
||||
let fixed = [all[0] - m[0], all[1] - m[1], all[2] - m[2], all[3] - m[3]];
|
||||
let refi = p.get("reference").and_then(Value::as_u64).unwrap_or(4).min(8) as usize;
|
||||
let rp = vectorcraft_geom::reference_point(v, refi);
|
||||
let (w, h) = wanted_size(p, v);
|
||||
// The geometric scale that gives the visual size: margins grow by the strokes' scale `f`. It is
|
||||
@@ -262,7 +262,7 @@ fn wanted_size(p: &Value, b: Rect) -> (f64, f64) {
|
||||
/// `b`, the box around the anchors (and the objects selected whole) square to the page, and only
|
||||
/// the anchors, their handles with them, and those objects move or scale.
|
||||
fn set_anchor_bounds(s: &mut Session, p: &Value, ids: Vec<NodeId>, b: Rect) -> Result<Value> {
|
||||
let refi = p.get("reference").and_then(Value::as_u64).unwrap_or(4).min(8) as usize;
|
||||
let refi = reference_index(p)?;
|
||||
let rp = vectorcraft_geom::reference_point(b, refi);
|
||||
let (w, h) = wanted_size(p, b);
|
||||
// A single anchor, or anchors in a line, have no size to scale on that side.
|
||||
@@ -272,6 +272,14 @@ fn set_anchor_bounds(s: &mut Session, p: &Value, ids: Vec<NodeId>, b: Rect) -> R
|
||||
apply_transform(s, "Transform", ids, Affine::translate(to - rp) * scale, p, true)
|
||||
}
|
||||
|
||||
fn reference_index(p: &Value) -> Result<usize> {
|
||||
let reference = crate::cmd::number_or(p, "reference", 4.0, "object.setBounds")?;
|
||||
if !reference.is_finite() || reference < 0.0 || reference.fract() != 0.0 {
|
||||
return Err(crate::cmd::bad("object.setBounds", "`reference` must be a whole number"));
|
||||
}
|
||||
Ok(reference.min(8.0) as usize)
|
||||
}
|
||||
|
||||
/// The visual box of `ids` square to `frame`, as [`Document::oriented_bounds`] measures it, with
|
||||
/// symbol instances measured without the strokes in their art
|
||||
/// ([`vectorcraft_doc::SymbolBoxes::without_art_strokes`]).
|
||||
|
||||
@@ -245,7 +245,15 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
crate::cmd::maskedit::outside_mask_editing,
|
||||
isolate
|
||||
),
|
||||
cmd!("object.exitIsolation", "Exit Isolation Mode", [], None, "{}", has_doc, exit_isolation),
|
||||
cmd!(
|
||||
"object.exitIsolation",
|
||||
"Exit Isolation Mode",
|
||||
[],
|
||||
None,
|
||||
"{} leave isolation mode; leaving an isolated Live Paint group adds the paths, compound paths and groups of them drawn in it (shown and unlocked with everything in them) to the group as livePaint.merge does, in one undo step, and leaves type, images and other objects in it as they are; object.isolate on a level outside the group does the same",
|
||||
has_doc,
|
||||
exit_isolation
|
||||
),
|
||||
cmd!(
|
||||
"object.setProps",
|
||||
"Object Properties",
|
||||
@@ -260,7 +268,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Align",
|
||||
["Window", "Align"],
|
||||
None,
|
||||
"{horizontal?: \"left\"|\"center\"|\"right\", vertical?: \"top\"|\"center\"|\"bottom\", to?: \"selection\"|\"artboard\"|\"key\" (default: the key object when the selection has one, select.key, else the selection; a key guide, select.key {guide}, stays put and the objects line up on its line: a vertical guide sets where left, center and right go and vertical alignment leaves them, a horizontal one the other way round; aligning to the key, the other selected ruler guides move too: a vertical guide to the key's left edge, center or right edge, a horizontal one to its top, center or bottom; aligning to the artboard moves selected guides to its edges too (#3463), and with only guides selected aligning to the selection moves them to their collective bounds), artboard?: index (0-based; with to: \"artboard\", the artboard to align to; the app passes the active one; default: the artboard under the center of the selection, else the first), bounds?: \"preview\"|\"geometric\" (default: the Use Preview Bounds preference; preview bounds take in strokes), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} With anchor points selected (Direct Selection), the points align instead: to their own bounds, to the artboard (#1180), or, aligning to the key with a key anchor (select.key {id, anchor}), to the key anchor, which stays put",
|
||||
"{horizontal?: \"left\"|\"center\"|\"right\", vertical?: \"top\"|\"center\"|\"bottom\", to?: \"selection\"|\"artboard\"|\"key\" (default: the key object when the selection has one, select.key, else the selection; a key guide, select.key {guide}, stays put and the objects line up on its line: a vertical guide sets where left, center and right go and vertical alignment leaves them, a horizontal one the other way round; aligning to the key, the other selected ruler guides move too: a vertical guide to the key's left edge, center or right edge, a horizontal one to its top, center or bottom; aligning to the artboard moves selected guides to its edges too (#3463), and with only guides selected aligning to the selection moves them to their collective bounds), artboard?: index (0-based; with to: \"artboard\", the artboard to align to; the app passes the active one; default: the artboard under the center of the selection, else the first), bounds?: \"preview\"|\"geometric\" (default: the Use Preview Bounds preference; preview bounds take in strokes, geometry effects and projected 3D art), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} With anchor points selected (Direct Selection), the points align instead: to their own bounds, to the artboard (#1180), or, aligning to the key with a key anchor (select.key {id, anchor}), to the key anchor, which stays put",
|
||||
has_selection_or_guides,
|
||||
align
|
||||
),
|
||||
@@ -269,7 +277,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Distribute",
|
||||
["Window", "Align"],
|
||||
None,
|
||||
"{horizontal?: \"left\"|\"center\"|\"right\", vertical?: \"top\"|\"center\"|\"bottom\", spacing?: pt (used with a key, select.key: the key object, or the key guide, select.key {guide}, stays put and the lines are placed this far apart, outward from its line, in their order on that line; 0 puts them all on its line; a key guide along the axis leaves everything where it is; not used without a key, or with anchor points selected and no key anchor), to?: \"selection\"|\"artboard\"|\"key\" (default: the key while there is one, else the selection; \"key\" without spacing distributes as \"selection\" does; with anchor points selected, with \"selection\" or \"artboard\" the key anchor is not the key and all the points are spaced as without one; not used with spacing and a key object; with a key guide, \"selection\" or \"artboard\" distributes without it as the key), artboard?: index (0-based; with to: \"artboard\", the artboard to distribute across; the app passes the active one; default: as object.align's), bounds?: \"preview\"|\"geometric\" (default: the Use Preview Bounds preference; preview bounds take in strokes), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} space the selected objects' left edges, centers or right edges (top edges, centers or bottom edges) in their order on that line, with the selected ruler guides across the axis (vertical ones for horizontal; #1597): a guide has no size, so its edges and center are its line, and guides along the axis stay. Without spacing and a key they are spaced evenly, the first and last stay put, and fewer than three don't move; with spacing and a key, see spacing (two are enough); with to: \"artboard\", the first one's left (top) edge goes to the artboard's left (top) edge, the last one's right (bottom) edge goes to the artboard's right (bottom) edge, and two are enough. With anchor points selected (Direct Selection), the points are spaced evenly between the first and the last along the axis instead (#1636); with spacing and a key anchor (select.key {id, anchor}), the key anchor stays put and the others are placed spacing apart, outward from it, in their order along the axis",
|
||||
"{horizontal?: \"left\"|\"center\"|\"right\", vertical?: \"top\"|\"center\"|\"bottom\", spacing?: pt (used with a key, select.key: the key object, or the key guide, select.key {guide}, stays put and the lines are placed this far apart, outward from its line, in their order on that line; 0 puts them all on its line; a key guide along the axis leaves everything where it is; not used without a key, or with anchor points selected and no key anchor), to?: \"selection\"|\"artboard\"|\"key\" (default: the key while there is one, else the selection; \"key\" without spacing distributes as \"selection\" does; with anchor points selected, with \"selection\" or \"artboard\" the key anchor is not the key and all the points are spaced as without one; not used with spacing and a key object; with a key guide, \"selection\" or \"artboard\" distributes without it as the key), artboard?: index (0-based; with to: \"artboard\", the artboard to distribute across; the app passes the active one; default: as object.align's), bounds?: \"preview\"|\"geometric\" (default: the Use Preview Bounds preference; preview bounds take in strokes, geometry effects and projected 3D art), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} space the selected objects' left edges, centers or right edges (top edges, centers or bottom edges) in their order on that line, with the selected ruler guides across the axis (vertical ones for horizontal; #1597): a guide has no size, so its edges and center are its line, and guides along the axis stay. Without spacing and a key they are spaced evenly, the first and last stay put, and fewer than three don't move; with spacing and a key, see spacing (two are enough); with to: \"artboard\", the first one's left (top) edge goes to the artboard's left (top) edge, the last one's right (bottom) edge goes to the artboard's right (bottom) edge, and two are enough. With anchor points selected (Direct Selection), the points are spaced evenly between the first and the last along the axis instead (#1636); with spacing and a key anchor (select.key {id, anchor}), the key anchor stays put and the others are placed spacing apart, outward from it, in their order along the axis",
|
||||
can_distribute,
|
||||
distribute
|
||||
),
|
||||
@@ -278,7 +286,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Distribute Spacing",
|
||||
["Window", "Align"],
|
||||
None,
|
||||
"{axis?: \"horizontal\"|\"vertical\" (default: \"horizontal\"), spacing?: pt (the key object, select.key, or the key guide, select.key {guide}, stays put and the others are spaced from it; a key guide along the axis leaves everything where it is), to?: \"selection\"|\"artboard\"|\"key\" (used without spacing, and with a key guide; with anchor points selected, with \"selection\" or \"artboard\" the key anchor is not the key and all the points are spaced as without one; default: the key while there is one, else the selection; \"key\" without spacing spaces as \"selection\" does), artboard?: index (0-based; with to: \"artboard\", the artboard to space across; the app passes the active one; default: as object.align's), bounds?: \"preview\"|\"geometric\" (default: the Use Preview Bounds preference; preview bounds take in strokes), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} without spacing, make the gaps between the selected objects equal, in the order of their left (top) edges, with the selected ruler guides across the axis as items with no size (#1597; guides along the axis stay): the first item's left (top) edge and the last one's right (bottom) edge stay put, or with to: \"artboard\" go to the artboard's left (top) and right (bottom) edges. With anchor points selected (Direct Selection), the points are spaced evenly along the axis instead, or `spacing` apart from the first (#1636), or with a key anchor (select.key {id, anchor}) `spacing` apart outward from the key anchor, which stays put",
|
||||
"{axis?: \"horizontal\"|\"vertical\" (default: \"horizontal\"), spacing?: pt (the key object, select.key, or the key guide, select.key {guide}, stays put and the others are spaced from it; a key guide along the axis leaves everything where it is), to?: \"selection\"|\"artboard\"|\"key\" (used without spacing, and with a key guide; with anchor points selected, with \"selection\" or \"artboard\" the key anchor is not the key and all the points are spaced as without one; default: the key while there is one, else the selection; \"key\" without spacing spaces as \"selection\" does), artboard?: index (0-based; with to: \"artboard\", the artboard to space across; the app passes the active one; default: as object.align's), bounds?: \"preview\"|\"geometric\" (default: the Use Preview Bounds preference; preview bounds take in strokes, geometry effects and projected 3D art), patterns?: bool (Transform Patterns: pattern fills and strokes transform with the art; default: prefs transformPatternTiles)} without spacing, make the gaps between the selected objects equal, in the order of their left (top) edges, with the selected ruler guides across the axis as items with no size (#1597; guides along the axis stay): the first item's left (top) edge and the last one's right (bottom) edge stay put, or with to: \"artboard\" go to the artboard's left (top) and right (bottom) edges. With anchor points selected (Direct Selection), the points are spaced evenly along the axis instead, or `spacing` apart from the first (#1636), or with a key anchor (select.key {id, anchor}) `spacing` apart outward from the key anchor, which stays put",
|
||||
can_distribute,
|
||||
distribute_spacing
|
||||
),
|
||||
@@ -287,7 +295,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Set Bounds",
|
||||
[],
|
||||
None,
|
||||
"{x?, y?, width?, height?, reference?: 0..8 (9-point grid; a number past 8 is read as 8), proportional?, strokes?, corners?, copy?: bool, patterns?: bool (Transform Patterns), typeAreas?: bool (area type: the frame is reshaped and the text reflows at its size), objects?: bool (Transform Objects, as object.move)} (Transform panel; width/height and the reference point follow the bounding box, rotated with rotated objects; x, y are page coordinates; with Use Preview Bounds the values measure the visual bounds; with the typeGlyphBounds preference, each point type object selected as an object (not inside a selected group) is measured by its glyphs' ink (underline and strikethrough included), which the scale gives the size asked for; strokes/corners as object.scale; with anchor points selected (Direct Selection) and no copy, the values are the box around those points, square to the page, and only they move or scale, as with object.move (#1824))",
|
||||
"{x?, y?, width?, height?, reference?: whole number >= 0 (9-point grid 0..8; 0.0 equals 0; a whole number past 8 is read as 8; omitted/null: center, 4), proportional?, strokes?, corners?, copy?: bool, patterns?: bool (Transform Patterns), typeAreas?: bool (area type: the frame is reshaped and the text reflows at its size), objects?: bool (Transform Objects, as object.move)} (Transform panel; width/height and the reference point follow the bounding box, rotated with rotated objects; x, y are page coordinates; with Use Preview Bounds the values measure the visual bounds; with the typeGlyphBounds preference, each point type object selected as an object (not inside a selected group) is measured by its glyphs' ink (underline and strikethrough included), which the scale gives the size asked for; strokes/corners as object.scale; with anchor points selected (Direct Selection) and no copy, the values are the box around those points, square to the page, and only they move or scale, as with object.move (#1824))",
|
||||
has_selection,
|
||||
set_bounds
|
||||
),
|
||||
|
||||
@@ -153,6 +153,20 @@ fn page_fonts(name: &str, bytes: &[u8], path: &str, pages: &PlacedPages) -> BTre
|
||||
fonts
|
||||
}
|
||||
|
||||
/// The document whose links are copied beside the placed file `name` (`bytes`), which is copied
|
||||
/// as it is: a `.ai` file's editing data ([`super::place::document::editing_data`]), or the native
|
||||
/// document an EPS or PostScript file carries, which placing it reads. `None` for other files and
|
||||
/// for data that can't be read.
|
||||
fn editing_data(name: &str, bytes: &[u8]) -> Option<Document> {
|
||||
if let Some(doc) = super::place::document::editing_data(name, bytes) {
|
||||
return Some(doc);
|
||||
}
|
||||
if !super::place::document::is_postscript(bytes) {
|
||||
return None;
|
||||
}
|
||||
vectorcraft_format::load(&vectorcraft_eps::native(bytes)?).ok()
|
||||
}
|
||||
|
||||
/// Collect dependencies depth-first so nested VectorCraft files are rewritten before
|
||||
/// their parents: each parent can record the final hash of the rewritten child.
|
||||
/// Cycles, excessive nesting, and unreadable children are reported, not fatal.
|
||||
@@ -200,7 +214,7 @@ impl<'a> Collector<'a> {
|
||||
self.warnings.push(message);
|
||||
}
|
||||
|
||||
/// Warns when a file that placed `.ai` file `source` links (`name`) was copied as `copy`: the
|
||||
/// Warns when a file that placed `.ai` or EPS file `source` links (`name`) was copied as `copy`: the
|
||||
/// copy of `source` finds it only by its name, beside it.
|
||||
/// `path` is the link's path as the warning names it.
|
||||
fn renamed(&mut self, lines: &mut Vec<String>, source: &str, path: &str, name: &str, copy: &str) {
|
||||
@@ -213,8 +227,8 @@ impl<'a> Collector<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Collects the files `doc` links. `by_name`: `doc` is a placed `.ai` file's editing data,
|
||||
/// whose links are not rewritten, so its copy finds them by name beside it. `lookup`: the
|
||||
/// Collects the files `doc` links. `by_name`: `doc` is a placed `.ai` or EPS file's editing
|
||||
/// data, whose links are not rewritten, so its copy finds them by name beside it. `lookup`: the
|
||||
/// document whose links (with the same paths as `doc`'s) are looked for, and where from, when
|
||||
/// not `doc` from `source`.
|
||||
fn collect(
|
||||
@@ -311,12 +325,13 @@ impl<'a> Collector<'a> {
|
||||
if by_name {
|
||||
self.renamed(&mut lines, source, &shown, &file.name, &destination_file);
|
||||
}
|
||||
// A placed PDF or .ai file is copied as it is, as an image is; the files a .ai file
|
||||
// read from its editing data links are copied beside it.
|
||||
// A placed PDF, .ai or EPS file is copied as it is, as an image is; the files a .ai
|
||||
// file read from its editing data, or an EPS file read from the native document it
|
||||
// carries, links are copied beside it.
|
||||
let pages = placed.get(&file.path);
|
||||
let placed_file = pages.is_some();
|
||||
check_carried_scripts(&file.name, &bytes, found_path)?;
|
||||
if placed_file && let Some(mut art) = super::place::document::editing_data(&file.name, &bytes) {
|
||||
if placed_file && let Some(mut art) = editing_data(&file.name, &bytes) {
|
||||
if depth >= vectorcraft_doc::placed_document::MAX_DEPTH {
|
||||
self.warn(&mut lines, format!("{shown}: nesting limit reached; copied unchanged without collecting its own links"));
|
||||
} else {
|
||||
|
||||
@@ -1276,7 +1276,7 @@ fn aligned_between(tab: &vectorcraft_doc::TabStop, from: f64, x: f64) -> bool {
|
||||
|
||||
/// The frames of the story that type object `id` belongs to (its thread in thread order, else `id`
|
||||
/// alone), each with the length of its text in bytes.
|
||||
fn story_frames(s: &Session, id: NodeId) -> Vec<(NodeId, usize)> {
|
||||
pub(crate) fn story_frames(s: &Session, id: NodeId) -> Vec<(NodeId, usize)> {
|
||||
let Some(st) = s.active() else { return vec![] };
|
||||
let d = &st.doc;
|
||||
let frames = d.text_threads.iter().find(|thread| thread.contains(&id)).cloned().unwrap_or_else(|| vec![id]);
|
||||
@@ -1314,6 +1314,16 @@ fn move_editing_selection(
|
||||
at + inserted.iter().filter(|(b, _)| *b <= at).map(|(_, n)| n).sum::<usize>()
|
||||
};
|
||||
let (anchor, caret) = (story(anchor), story(caret));
|
||||
select_story_range(s, id, anchor, caret)
|
||||
}
|
||||
|
||||
/// The Type tool's anchor and caret become story positions `anchor` and `caret` of the story that
|
||||
/// frame `id` belongs to, as its frames are now. The caret stays in `id` while its place is there,
|
||||
/// and else goes to the frame that holds it, with the anchor in that frame; that frame becomes the
|
||||
/// selection when it was not selected.
|
||||
pub(crate) fn select_story_range(s: &mut Session, id: NodeId, anchor: usize, caret: usize) -> Result<()> {
|
||||
let start_of = |frames: &[(NodeId, usize)], f: NodeId| frames.iter().take_while(|(g, _)| *g != f).map(|(_, n)| n).sum::<usize>();
|
||||
let len_of = |frames: &[(NodeId, usize)], f: NodeId| frames.iter().find(|(g, _)| *g == f).map_or(0, |(_, n)| *n);
|
||||
let after = story_frames(s, id);
|
||||
let fits = |f: NodeId| (start_of(&after, f)..=start_of(&after, f) + len_of(&after, f)).contains(&caret);
|
||||
let frame = if fits(id) { Some(id) } else { after.iter().map(|(f, _)| *f).find(|f| fits(*f)) };
|
||||
|
||||
@@ -649,6 +649,7 @@ pub const UNCHECKED: &[&str] = &[
|
||||
"transparency.setOpacityMask",
|
||||
"transparency.unlinkOpacityMask",
|
||||
"type.pathOptions",
|
||||
"webExport.optimizeToFileSize",
|
||||
"webExport.presets.save",
|
||||
"webExport.settings",
|
||||
];
|
||||
@@ -663,18 +664,28 @@ fn pdf_option_tree() -> Value {
|
||||
tree
|
||||
}
|
||||
|
||||
/// The parameter error of command `id` for `key`, a key with the objects it is in (`marks.ofset`),
|
||||
/// when a key those objects take is near it: `near`, written the same way (`marks.offset`). Each
|
||||
/// is one value of the message, so a catalog can match the message and translate it.
|
||||
fn misspelled(id: &str, key: &str, near: &str) -> crate::EngineError {
|
||||
bad(id, format!("unknown parameter `{key}`; did you mean `{near}`?"))
|
||||
}
|
||||
|
||||
/// `given`, the object at `within` (`marks.`), has only keys of `schema`, the objects inside it too.
|
||||
fn check_option_tree(id: &str, within: &str, given: &serde_json::Map<String, Value>, schema: &serde_json::Map<String, Value>) -> Result<()> {
|
||||
for (key, value) in given {
|
||||
match (schema.get(key), value) {
|
||||
(None, _) => {
|
||||
let keys: Vec<&str> = schema.keys().map(String::as_str).collect();
|
||||
let why = match nearest(key, &keys) {
|
||||
Some(near) => format!("did you mean `{within}{near}`?"),
|
||||
None => format!("`{}` takes: {}", within.trim_end_matches('.'), keys.join(", ")),
|
||||
};
|
||||
let key = shown_key(key);
|
||||
return Err(bad(id, format!("unknown parameter `{within}{key}`; {why}")));
|
||||
let near = nearest(key, &keys);
|
||||
let key = format!("{within}{}", shown_key(key));
|
||||
return Err(match near {
|
||||
Some(near) => misspelled(id, &key, &format!("{within}{near}")),
|
||||
None => {
|
||||
let (object, keys) = (within.trim_end_matches('.'), keys.join(", "));
|
||||
bad(id, format!("unknown parameter `{key}`; `{object}` takes: {keys}"))
|
||||
}
|
||||
});
|
||||
}
|
||||
(Some(Value::Object(inner)), Value::Object(value)) => check_option_tree(id, &format!("{within}{key}."), value, inner)?,
|
||||
_ => {}
|
||||
@@ -691,14 +702,11 @@ fn check_option_keys(id: &str, within: &str, given: &serde_json::Map<String, Val
|
||||
for (key, value) in given {
|
||||
if !keys.contains(&key.as_str()) {
|
||||
let near = nearest(key, keys);
|
||||
let key = shown_key(key);
|
||||
return Err(bad(
|
||||
id,
|
||||
match near {
|
||||
Some(near) => format!("unknown parameter `{within}{key}`; did you mean `{within}{near}`?"),
|
||||
None => format!("unknown parameter `{within}{key}`; {why_not}"),
|
||||
},
|
||||
));
|
||||
let key = format!("{within}{}", shown_key(key));
|
||||
return Err(match near {
|
||||
Some(near) => misspelled(id, &key, &format!("{within}{near}")),
|
||||
None => bad(id, format!("unknown parameter `{key}`; {why_not}")),
|
||||
});
|
||||
}
|
||||
if let (Some(Value::Object(schema)), Value::Object(value)) = (trees.get(key), value) {
|
||||
check_option_tree(id, &format!("{within}{key}."), value, schema)?;
|
||||
@@ -797,12 +805,15 @@ fn check_screen_rows(id: &str, within: &str, p: &serde_json::Map<String, Value>)
|
||||
let formats = screen_formats();
|
||||
for (format, options) in settings {
|
||||
if !formats.contains(&format.as_str()) {
|
||||
let why = match nearest(format, &formats) {
|
||||
Some(near) => format!("did you mean `{within}settings.{near}`?"),
|
||||
None => format!("`{within}settings` takes: {}", formats.join(", ")),
|
||||
};
|
||||
let format = shown_key(format);
|
||||
return Err(bad(id, format!("unknown parameter `{within}settings.{format}`; {why}")));
|
||||
let near = nearest(format, &formats);
|
||||
let key = format!("{within}settings.{}", shown_key(format));
|
||||
return Err(match near {
|
||||
Some(near) => misspelled(id, &key, &format!("{within}settings.{near}")),
|
||||
None => {
|
||||
let (object, keys) = (format!("{within}settings"), formats.join(", "));
|
||||
bad(id, format!("unknown parameter `{key}`; `{object}` takes: {keys}"))
|
||||
}
|
||||
});
|
||||
}
|
||||
if let Value::Object(options) = options {
|
||||
check_option_keys(id, &format!("{within}settings.{format}."), options, &keys, NO_FORMAT, trees)?;
|
||||
|
||||
@@ -1874,20 +1874,85 @@ fn cut_at_anchors(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
}
|
||||
cut.finish(d)?;
|
||||
// Each cut leaves one of its two coincident anchors selected, so a drag pulls the ends apart.
|
||||
sel.clear();
|
||||
for (id, a) in picked {
|
||||
sel.add(id);
|
||||
sel.anchors.entry(id).or_default().insert(a);
|
||||
}
|
||||
select_cut_ends(sel, &picked);
|
||||
Ok(all)
|
||||
})?;
|
||||
Ok(super::draw2::ids_json(&ids))
|
||||
}
|
||||
|
||||
/// Replaces the selection with the anchors in `picked`: each id once, in the order it first
|
||||
/// appears, with every anchor listed for it. An empty `picked` clears the selection.
|
||||
fn select_cut_ends(sel: &mut Selection, picked: &[(NodeId, (usize, usize))]) {
|
||||
sel.set(picked.iter().map(|(id, _)| *id));
|
||||
for (id, a) in picked {
|
||||
sel.anchors.entry(*id).or_default().insert(*a);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// `select_cut_ends` by clearing the selection and adding each id in turn, kept as the
|
||||
/// reference the one-call version must match.
|
||||
fn select_cut_ends_one_by_one(sel: &mut Selection, picked: &[(NodeId, (usize, usize))]) {
|
||||
sel.clear();
|
||||
for (id, a) in picked {
|
||||
sel.add(*id);
|
||||
sel.anchors.entry(*id).or_default().insert(*a);
|
||||
}
|
||||
}
|
||||
|
||||
/// A selection with every field set, the art made since the last deselect included.
|
||||
fn busy_selection() -> Selection {
|
||||
Selection {
|
||||
objects: vec![NodeId(90), NodeId(91)],
|
||||
anchors: [(NodeId(90), [(0, 3)].into())].into(),
|
||||
segments: [(NodeId(91), [(0, 1)].into())].into(),
|
||||
key: Some(NodeId(90)),
|
||||
target: Some(NodeId(91)),
|
||||
slices: vec![NodeId(92)],
|
||||
guides: vec![NodeId(93)],
|
||||
key_guide: Some(NodeId(93)),
|
||||
key_anchor: Some((NodeId(90), (0, 3))),
|
||||
symbol_part: Some(vectorcraft_doc::SymbolPart { instance: NodeId(94), path: vec![0, 2] }),
|
||||
on_path_member: Some(NodeId(95)),
|
||||
new_art: Arc::new([NodeId(90), NodeId(97)].into()),
|
||||
}
|
||||
}
|
||||
|
||||
/// The cut ends of open paths, of an opened closed path, of a path of several subpaths (one id
|
||||
/// with several anchors, first seen before other ids), long lists and an empty one give the
|
||||
/// same selection, every field, as clearing it and adding each id in turn.
|
||||
#[test]
|
||||
fn selecting_cut_ends_matches_adding_them_one_by_one() {
|
||||
let n = NodeId;
|
||||
let mut cases: Vec<Vec<(NodeId, (usize, usize))>> = vec![
|
||||
vec![],
|
||||
vec![(n(1), (0, 0)), (n(2), (0, 0))],
|
||||
vec![(n(5), (0, 0))],
|
||||
vec![(n(7), (0, 0)), (n(3), (1, 0)), (n(8), (0, 0)), (n(3), (2, 0)), (n(7), (0, 0)), (n(3), (0, 0))],
|
||||
];
|
||||
let mut rng = Lcg(11);
|
||||
for len in [50, 2_000] {
|
||||
cases.push((0..len).map(|_| (n(rng.below(300) + 1), (rng.below(4) as usize, 0))).collect());
|
||||
}
|
||||
for picked in &cases {
|
||||
for start in [Selection::default(), busy_selection()] {
|
||||
let (mut ours, mut theirs) = (start.clone(), start.clone());
|
||||
select_cut_ends(&mut ours, picked);
|
||||
select_cut_ends_one_by_one(&mut theirs, picked);
|
||||
assert_eq!(ours, theirs, "{picked:?}");
|
||||
assert_eq!(ours.new_art, start.new_art);
|
||||
}
|
||||
}
|
||||
let mut sel = busy_selection();
|
||||
select_cut_ends(&mut sel, &cases[3]);
|
||||
assert_eq!(sel.objects, [n(7), n(3), n(8)]);
|
||||
assert_eq!(sel.anchors[&n(3)].iter().collect::<Vec<_>>(), [&(0, 0), &(1, 0), &(2, 0)]);
|
||||
assert_eq!((sel.anchors.len(), sel.key, sel.target, sel.symbol_part.is_some()), (3, None, None, false));
|
||||
}
|
||||
|
||||
/// `merge_coincident` removing each merged anchor from the vector straight away, kept as the
|
||||
/// reference the one-pass version must match.
|
||||
fn merge_coincident_by_removal(sp: &mut SubPath, picked: impl Fn(usize) -> bool, join_kind: Option<bool>) -> usize {
|
||||
|
||||
@@ -91,7 +91,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Placed File Info",
|
||||
[],
|
||||
None,
|
||||
"{path | name | dataBase64 (a file's path, or its name with its bytes), page?, crop?, password?, thumbnail?: px, link?: bool, dxf?: {…}, layers?, hiddenLayers?, importSlices? (all as file.place)} what file.place would place, without placing it → {name, format, width, height (pt at 100%), pixelWidth?, pixelHeight?, ppi?: [x, y], colorMode?: RGB|Grayscale|CMYK (raster images), plates?: [ink names] (a DCS file), slices?: the user slices a PSD or PSB file would bring in, warnings, thumbnailBase64?: PNG of at most `thumbnail` (≤ 512) px on its longer side}",
|
||||
"{path | name | dataBase64 (a file's path, or its name with its bytes), page?, crop?, password?, thumbnail?: px, link?: bool, dxf?: {…}, layers?, hiddenLayers?, importSlices? (all as file.place)} what file.place would place, without placing it → {name, format, width, height (pt at 100%), pixelWidth?, pixelHeight?, ppi?: [x, y], colorMode?: RGB|Grayscale|CMYK (raster images; opaque CMYK PSD/PSB merged images keep 8- or 16-bit inks within VectorCraft's 67,108,864-pixel native CMYK limit and allocation allowance; other CMYK composites use the RGB decoder's allocation limit), plates?: [ink names] (a DCS file), slices?: the user slices a PSD or PSB file would bring in, warnings, thumbnailBase64?: PNG of at most `thumbnail` (≤ 512) px on its longer side}",
|
||||
always,
|
||||
info
|
||||
),
|
||||
|
||||
@@ -548,6 +548,7 @@ pub(super) const ALLOWED: &[&str] = &[
|
||||
"select.toggle",
|
||||
"select.update",
|
||||
"shape.arc",
|
||||
"shape.circleThroughPoints",
|
||||
"shape.ellipse",
|
||||
"shape.flare",
|
||||
"shape.line",
|
||||
|
||||
@@ -23,7 +23,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Print Setup",
|
||||
[],
|
||||
None,
|
||||
"{preset?: name ([Default] or a saved print preset, any case: print.presets.list; its settings replace the document's, as choosing it in the Print dialog does), settings?: {copies: 1 (1–999), collate: true, reverse, artboards: all|range|ignore (all the art as one page), range: \"1-3, 5\" (1-based, with artboards: range), skipBlank (leave out artboards with no art that prints), media: letter|legal|tabloid|a3|a4|a5|a6|b4|b5|b4 (jis)|b5 (jis)|b6 (jis)|japanese postcard|japanese double postcard|japanese envelope #3|japanese envelope #4|kaku #2|kaku #3|yonroku-ban|custom (a paper is named by its id or its dialog label, any case and spacing, so `B5 (JIS)` works; b4 and b5 stay the ISO 216 sizes, 250 × 353 and 176 × 250 mm, and the JIS sizes are b4 (jis) 257 × 364 mm, b5 (jis) 182 × 257 mm and b6 (jis) 128 × 182 mm), width, height (custom paper, 72–14400 pt), orientation: portrait|landscape|portraitFlipped|landscapeFlipped, autoRotate: true (turn the paper to each artboard; orientation ignored), transverse (the page a quarter turn on the paper), printLayers: visiblePrintable|visible|all (template layers never print), placement: {origin: topLeft|top|topRight|left|center|right|bottomLeft|bottom|bottomRight (the point of the printed area, the artboard with its bleed and marks, on the same point of the imageable area), x, y (pt, right and down)}, scaling: none|fit|custom|tileFull|tileImageable, scale: {width: 100, height: 100} (% with custom and tiling), overlap: 0 (pt between tiles), tileRange: \"\" (1-based tiles across then down; empty: all), copiesPerSheet: false (not with tiling: as many copies of each artboard, with its bleed and marks, as fit the imageable area, across then down, not turned; the placement places the grid; an artboard that doesn't fit prints one copy per sheet, with a warning), gutter: 0 (pt between copies, 0–720), margin: 0 (pt the device can't print around the paper: the imageable area is inside it), marks: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25, offset: 6} (as document.exportPdf, at the paper's scale; page information adds the tile and the ink), bleed: {useDocument: true (the document's bleed, document.setup), top, bottom, left, right} (pt), output: {mode: composite|separations (one grey page per ink that prints), emulsion: up|down (down mirrors), image: positive|negative, spotsToProcess, inks: [{name: \"Cyan\"|…|a spot swatch, print: true, frequency (lpi, default 60), angle (screen angle, degrees counter-clockwise as PostScript setscreen takes it; default C 15, M 75, Y 0, K 45, spots 45)}]}, graphics: {autoFlatness: true, flatness: 1 (0.2–100), fonts: none|subset|complete}, color: {intent: perceptual|relativeColorimetric|saturation|absoluteColorimetric, preserveNumbers: true (CMYK colours keep their values), profile: \"\" (the printer profile, an RGB or CMYK one: composite PDF colours are converted to it with the intent, separations separate with a CMYK one; empty: as they are)}, advanced: {printAsBitmap (composite pages print as one image each, at the document's raster effects resolution, or lower for a page larger than 64 Mpx or 32,768 px a side), overprints: preserve|discard|simulate (composite output; preserve writes them to overprint (/OP), simulate prints them as Overprint Preview shows them; separations always keep them), flattenerPreset: \"\" (a flattener preset, built-in or saved: transparency is flattened before printing; empty: it prints live; PostScript defaults to medium)}, tileOrigin: {placed: false, x, y} (where the Print Tiling tool put the pages: print.tiling.set)}} store the print settings with the document, over the ones it has or the preset's (null keeps a value), as one undo step; no settings or preset → {settings} (the current ones, defaults if never set up)",
|
||||
"{preset?: name ([Default] or a saved print preset, any case: print.presets.list; its settings replace the document's, as choosing it in the Print dialog does), settings?: {copies: 1 (1–999), collate: true, reverse, artboards: all|range|ignore (all the art as one page), range: \"1-3, 5\" (1-based, with artboards: range), skipBlank (leave out artboards with no art that prints), media: letter|legal|tabloid|a3|a4|a5|a6|b4|b5|b4 (jis)|b5 (jis)|b6 (jis)|japanese postcard|japanese double postcard|japanese envelope #3|japanese envelope #4|kaku #2|kaku #3|yonroku-ban|custom (a paper is named by its id or its dialog label, any case and spacing, so `B5 (JIS)` works; b4 and b5 stay the ISO 216 sizes, 250 × 353 and 176 × 250 mm, and the JIS sizes are b4 (jis) 257 × 364 mm, b5 (jis) 182 × 257 mm and b6 (jis) 128 × 182 mm), width, height (custom paper, 72–14400 pt), orientation: portrait|landscape|portraitFlipped|landscapeFlipped, autoRotate: true (turn the paper to each artboard; orientation ignored), transverse (the page a quarter turn on the paper), printLayers: visiblePrintable|visible|all (template layers never print), placement: {origin: topLeft|top|topRight|left|center|right|bottomLeft|bottom|bottomRight (the point of the printed area, the artboard with its bleed and marks, on the same point of the imageable area), x, y (pt, right and down)}, scaling: none|fit|custom|tileFull|tileImageable, scale: {width: 100, height: 100 (1–1000 % with custom and tiling), linked: true (width and height stay equal: give one and the other follows, and turning it on sets the height to the width; a different width and height without linked turn it off, and with linked: true, or linked: null over a linked scale, are an error; a saved scale without linked reads it as false)}, overlap: 0 (pt between tiles), tileRange: \"\" (1-based tiles across then down; empty: all), copiesPerSheet: false (not with tiling: as many copies of each artboard, with its bleed and marks, as fit the imageable area, across then down, not turned; the placement places the grid; an artboard that doesn't fit prints one copy per sheet, with a warning), gutter: 0 (pt between copies, 0–720), margin: 0 (pt the device can't print around the paper: the imageable area is inside it), marks: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25, offset: 6} (as document.exportPdf, at the paper's scale; page information adds the tile and the ink), bleed: {useDocument: true (the document's bleed, document.setup), top, bottom, left, right} (pt), output: {mode: composite|separations (one gray page per ink that prints), emulsion: up|down (down mirrors), image: positive|negative, spotsToProcess, overprintBlack: false (separations: solid 100% K or 100% gray fills, strokes and characters, to within half a percent, overprint in the printed copy, gradients when every stop is (every point of a freeform one); rich, RGB, spot-linked and lighter blacks are not marked, and paints already set to overprint keep it; composite ignores it), inks: [{name: \"Cyan\"|…|a spot swatch, print: true, frequency (lpi, default 60), angle (screen angle, degrees counter-clockwise as PostScript setscreen takes it; default C 15, M 75, Y 0, K 45, spots 45), convertToProcess: false (a spot ink only: it prints on the process plates, with no plate of its own, and its print, frequency and angle are kept for when it prints as a spot ink again; spotsToProcess converts every spot ink whatever it says)}]}, graphics: {autoFlatness: true, flatness: 1 (0.2–100), fonts: none|subset|complete}, color: {intent: perceptual|relativeColorimetric|saturation|absoluteColorimetric, preserveNumbers: true (CMYK colors keep their values), profile: \"\" (the printer profile, an RGB or CMYK one: composite PDF colors are converted to it with the intent, separations separate with a CMYK one; empty: as they are)}, advanced: {printAsBitmap (composite pages print as one image each, at the document's raster effects resolution, or lower for a page larger than 64 Mpx or 32,768 px a side), overprints: preserve|discard|simulate (composite output; preserve writes them to overprint (/OP), simulate prints them as Overprint Preview shows them; separations always keep them), flattenerPreset: \"\" (a flattener preset, built-in or saved: transparency is flattened before printing; empty: it prints live; PostScript defaults to medium)}, tileOrigin: {placed: false, x, y} (where the Print Tiling tool put the pages: print.tiling.set)}} store the print settings with the document, over the ones it has or the preset's (null keeps a value), as one undo step; no settings or preset → {settings} (the current ones, defaults if never set up)",
|
||||
has_doc,
|
||||
setup
|
||||
),
|
||||
@@ -32,7 +32,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Print Preview",
|
||||
[],
|
||||
None,
|
||||
"{preset?: name (as print.setup's: its settings instead of the document's), settings?: {…settings of print.setup} (over the document's or the preset's)} → {pages (copies included), sheets: [{artboard (0-based; null with artboards ignored), tile? (1-based), ink? (separations), width, height (pt, the page), orientation, scale: [width %, height %], transform: [a, b, c, d, e, f] (document space → the page, pt, y down), area: [x0, y0, x1, y1] (the document region the page prints), trim: [x0, y0, x1, y1] (the artboard on the page; with copies per sheet, the box around every copy's), copies?: [[x0, y0, x1, y1]…] (copies per sheet: each copy's artboard on the page, across then down)}] (one copy, in order), tiles: [{artboard, columns, rows, printed: [1-based tiles], tiles: [[x0, y0, x1, y1]…] (document space)}], inks: [{name, spot, print, frequency, angle}] (separations), warnings (art larger than the imageable area, type that prints in the fallback font, type that doesn't fit its frame, options not applied yet…), settings} without printing",
|
||||
"{preset?: name (as print.setup's: its settings instead of the document's), settings?: {…settings of print.setup} (over the document's or the preset's)} → {pages (copies included), sheets: [{artboard (0-based; null with artboards ignored), tile? (1-based), ink? (separations), width, height (pt, the page), orientation, scale: [width %, height %], transform: [a, b, c, d, e, f] (document space → the page, pt, y down), area: [x0, y0, x1, y1] (the document region the page prints), trim: [x0, y0, x1, y1] (the artboard on the page; with copies per sheet, the box around every copy's), copies?: [[x0, y0, x1, y1]…] (copies per sheet: each copy's artboard on the page, across then down)}] (one copy, in order), tiles: [{artboard, columns, rows, printed: [1-based tiles], tiles: [[x0, y0, x1, y1]…] (document space)}], inks: [{name, spot, print, frequency, angle}] (separations: the plates), documentInks: [{name, spot, print, frequency, angle, convertToProcess?: true (a spot ink printing as process, with no plate)}] (separations: every ink of the document), warnings (art larger than the imageable area, type that prints in the fallback font, type that doesn't fit its frame, options not applied yet…), settings} without printing",
|
||||
has_doc,
|
||||
preview
|
||||
),
|
||||
@@ -82,11 +82,38 @@ pub(crate) fn settings_over(cmd: &str, mut v: Value, p: &Value) -> Result<PrintS
|
||||
Some(over @ Value::Object(_)) => merge(&mut v, over),
|
||||
Some(_) => return Err(bad(cmd, "settings must be an object")),
|
||||
}
|
||||
link_scale(cmd, &mut v, p.get("settings").and_then(|s| s.get("scale")).filter(|s| s.is_object()))?;
|
||||
let set = PrintSettings::deserialize(&v).map_err(|e| bad(cmd, format!("print settings: {e}")))?;
|
||||
set.check().map_err(|e| pdf_error(cmd, e))?;
|
||||
Ok(set)
|
||||
}
|
||||
|
||||
/// Keep the custom scale's width and height equal in the merged settings `v` while `scale.linked`
|
||||
/// is on, after `over` (the request's `scale`) was merged in: the one side the request gives sets
|
||||
/// the other, and otherwise the height takes the width (as turning the link on does). A request
|
||||
/// that gives a different width and height without a `linked` key turns the link off; with
|
||||
/// `linked: true`, or with `linked: null` over a linked scale, it is refused.
|
||||
fn link_scale(cmd: &str, v: &mut Value, over: Option<&Value>) -> Result<()> {
|
||||
let given = |k: &str| over.and_then(|o| o.get(k)).filter(|x| !x.is_null());
|
||||
let (width, height) = (given("width").cloned(), given("height").cloned());
|
||||
let apart = matches!((&width, &height), (Some(w), Some(h)) if w.as_f64() != h.as_f64());
|
||||
let Some(scale) = v.get_mut("scale").and_then(Value::as_object_mut) else { return Ok(()) };
|
||||
if apart && over.and_then(|o| o.get("linked")).is_none() {
|
||||
scale.insert("linked".into(), Value::Bool(false));
|
||||
}
|
||||
if scale.get("linked") != Some(&Value::Bool(true)) {
|
||||
return Ok(());
|
||||
}
|
||||
if apart {
|
||||
return Err(bad(cmd, "scale: give one percentage, or the same width and height, while scale.linked is on (linked: false scales them apart)"));
|
||||
}
|
||||
let (from, to) = if width.is_none() && height.is_some() { ("height", "width") } else { ("width", "height") };
|
||||
if let Some(value) = scale.get(from).cloned() {
|
||||
scale.insert(to.into(), value);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn to_json(set: &PrintSettings) -> Result<Value> {
|
||||
serde_json::to_value(set).map_err(|e| EngineError::Other(e.to_string()))
|
||||
}
|
||||
|
||||
@@ -378,11 +378,12 @@ pub(crate) fn raster_pixels(d: &Document, n: &Node, below: bool, members: bool)
|
||||
/// The image Object › Rasterize makes of `n` with the options of `n`'s Effect › Rasterize, when
|
||||
/// that is its only visible raster effect and is its own (not a fill's or a stroke's): made of `n`
|
||||
/// without that effect and without its transparency, which stays on the object. When Transform
|
||||
/// effects after the Rasterize effect move its image ([`vectorcraft_render::rasterize_stage`]),
|
||||
/// the image is made of the art before them and moved by them, as the canvas draws it. `None`
|
||||
/// otherwise, when those Transform effects flatten the image, or when the image can't be made.
|
||||
/// effects after the Rasterize effect move or copy its image ([`vectorcraft_render::rasterize_stage`]),
|
||||
/// the image is made of the art before them once and placed by each of their maps, as the canvas
|
||||
/// draws it: with copies, a group of the placements with the lowest first. `None` otherwise, when
|
||||
/// those Transform effects flatten every placement, or when the image can't be made.
|
||||
fn rasterize_effect_image(d: &mut Document, n: &Node) -> Option<Node> {
|
||||
let (whole, r, map) = rasterize_effect_art(d, n)?;
|
||||
let (whole, r, maps) = rasterize_effect_art(d, n)?;
|
||||
let p = json!({
|
||||
"ppi": r.ppi.unwrap_or(d.raster_effects_ppi),
|
||||
"colorModel": r.color_model.id(),
|
||||
@@ -395,33 +396,58 @@ fn rasterize_effect_image(d: &mut Document, n: &Node) -> Option<Node> {
|
||||
// image's transparency would need one too; upgrade when CMYK images carry alpha.
|
||||
let image = super::menucmds::rasterize_art(d, vec![whole], &p, "object.rasterize", false).ok()?;
|
||||
let mut image = image.into_node(d);
|
||||
if let Some(map) = map {
|
||||
image.transform(map, false);
|
||||
match maps.as_deref() {
|
||||
None => Some(image),
|
||||
Some([map]) => {
|
||||
image.transform(*map, false);
|
||||
Some(image)
|
||||
}
|
||||
Some(maps) => {
|
||||
// Each placement is an object of its own on the one image's pixels.
|
||||
let placed: Vec<Arc<Node>> = maps
|
||||
.iter()
|
||||
.map(|map| {
|
||||
let mut copy = d.reid(&image);
|
||||
copy.transform(*map, false);
|
||||
Arc::new(copy)
|
||||
})
|
||||
.collect();
|
||||
Some(Node::group(d.alloc_id(), placed))
|
||||
}
|
||||
}
|
||||
Some(image)
|
||||
}
|
||||
|
||||
/// What [`rasterize_effect_image`] makes its image of: `n`, or the art before the Transform effects
|
||||
/// that move the image, without the Rasterize effect and without its transparency; that effect's
|
||||
/// options; and the map those Transform effects move the image by. `None` when `n` has another
|
||||
/// raster effect, when the Rasterize effect is not its own, or when those Transform effects
|
||||
/// flatten the image.
|
||||
fn rasterize_effect_art(d: &Document, n: &Node) -> Option<(Node, effects::Rasterize, Option<Affine>)> {
|
||||
/// that move or copy the image, without the Rasterize effect and without its transparency; that
|
||||
/// effect's options; and the maps those Transform effects place the image by, the lowest first,
|
||||
/// without those that flatten it. `None` when `n` has another raster effect, when the Rasterize
|
||||
/// effect is not its own, or when those Transform effects flatten every placement.
|
||||
fn rasterize_effect_art(d: &Document, n: &Node) -> Option<(Node, effects::Rasterize, Option<Vec<Affine>>)> {
|
||||
let [RasterFx::Rasterize(r)] = raster_fx(n)[..] else { return None };
|
||||
let staged = vectorcraft_render::rasterize_stage(d, n);
|
||||
if let Some((_, map)) = &staged
|
||||
&& !(map.determinant().is_finite() && map.determinant().abs() > 1e-12)
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let (stage, map) = staged.map_or((None, None), |(stage, map)| (Some(stage), Some(map)));
|
||||
let (stage, maps) = match vectorcraft_render::rasterize_stage(d, n) {
|
||||
Some((stage, maps)) => {
|
||||
let maps: Vec<Affine> = maps.into_iter().filter(|m| places(*m)).collect();
|
||||
if maps.is_empty() {
|
||||
return None;
|
||||
}
|
||||
(Some(stage), Some(maps))
|
||||
}
|
||||
None => (None, None),
|
||||
};
|
||||
let n = stage.as_ref().unwrap_or(n);
|
||||
let at = n.appearance.effects.iter().position(|e| e.visible && e.id == effects::RASTERIZE)?;
|
||||
let mut whole = n.clone();
|
||||
whole.appearance.effects.remove(at);
|
||||
(whole.opacity, whole.blend) = (1.0, Default::default());
|
||||
whole.extras_mut().mask = None;
|
||||
Some((whole, r, map))
|
||||
Some((whole, r, maps))
|
||||
}
|
||||
|
||||
/// Does `map`, one of those a Rasterize image is placed by ([`vectorcraft_render::rasterize_stage`]),
|
||||
/// place it? Not when it flattens it to a line or a point: the canvas draws nothing there.
|
||||
fn places(map: Affine) -> bool {
|
||||
let det = map.determinant();
|
||||
det.is_finite() && det.abs() > 1e-12
|
||||
}
|
||||
|
||||
/// `v` (an object without its raster effects) replaced by `image` of the object with them: the
|
||||
@@ -658,27 +684,32 @@ fn walk_all(out: &mut Document, nodes: &[Arc<Node>], report: &mut FlattenReport)
|
||||
.then(|| nodes.iter().map(|n| walk(out, n, report).map(Arc::new).unwrap_or_else(|| n.clone())).collect())
|
||||
}
|
||||
|
||||
/// `n` as an image when its Rasterize image moves with the Transform effects after it
|
||||
/// ([`vectorcraft_render::rasterize_stage`]): the image is made of the art before those Transform
|
||||
/// effects and moved by them, as the canvas draws it, which baking the geometry effects first would
|
||||
/// lose. A map that flattens the image leaves an empty group, as the canvas draws nothing. Inside
|
||||
/// groups, layers and opacity masks, the members are looked at the same way. `None` when nothing in
|
||||
/// `n` changes; hidden objects and template layers stay as they are.
|
||||
/// `n` as an image when its Rasterize image moves with the Transform effects after it, or as a
|
||||
/// group of that image's placements when they copy it ([`vectorcraft_render::rasterize_stage`]):
|
||||
/// the image is made of the art before those Transform effects and placed by them, as the canvas
|
||||
/// draws it, which baking the geometry effects first would lose. Maps that flatten every placement
|
||||
/// leave an empty group, as the canvas draws nothing. Inside groups, layers and opacity masks, the
|
||||
/// members are looked at the same way. `None` when nothing in `n` changes; hidden objects and
|
||||
/// template layers stay as they are.
|
||||
fn staged(out: &mut Document, n: &Node, report: &mut FlattenReport) -> Option<Node> {
|
||||
if !n.visible || matches!(n.kind, NodeKind::Layer { template: true, .. }) {
|
||||
return None;
|
||||
}
|
||||
if let Some((_, map)) = vectorcraft_render::rasterize_stage(out, n) {
|
||||
if let Some((_, maps)) = vectorcraft_render::rasterize_stage(out, n) {
|
||||
let mut v = n.clone();
|
||||
strip_raster(&mut v, false);
|
||||
let det = map.determinant();
|
||||
if !(det.is_finite() && det.abs() > 1e-12) {
|
||||
if !maps.iter().any(|m| places(*m)) {
|
||||
v.appearance = Default::default();
|
||||
v.kind = NodeKind::Group { children: vec![], clip: false };
|
||||
return Some(v);
|
||||
}
|
||||
let image = raster_image(out, n, false, false)?;
|
||||
report.record(n, &image);
|
||||
// The placements share one image: its resolution is the first one's.
|
||||
let first = match &image.kind {
|
||||
NodeKind::Group { children, clip: false } => children.first().map_or(&image, |c| &**c),
|
||||
_ => &image,
|
||||
};
|
||||
report.record(n, first);
|
||||
let mut m = replace_with_image(v, image);
|
||||
staged_mask(out, &mut m, report);
|
||||
return Some(m);
|
||||
|
||||
@@ -66,11 +66,13 @@ impl FlattenReport {
|
||||
lowest
|
||||
.into_iter()
|
||||
.map(|r| {
|
||||
let name = r.name.map(|name| format!(" ({name})")).unwrap_or_default();
|
||||
format!(
|
||||
"raster effects on object {}{name}: requested {:.1} ppi, achieved {:.1} ppi due to the 64 million pixel cap",
|
||||
r.id.0, self.requested_ppi, r.achieved_ppi
|
||||
)
|
||||
// The id and the name are one value of the message, so a catalog can match it.
|
||||
let object = match r.name {
|
||||
Some(name) => format!("{} ({name})", r.id.0),
|
||||
None => r.id.0.to_string(),
|
||||
};
|
||||
let (requested, achieved) = (self.requested_ppi, r.achieved_ppi);
|
||||
format!("raster effects on object {object}: requested {requested:.1} ppi, achieved {achieved:.1} ppi due to the 64 million pixel cap")
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
@@ -127,4 +129,23 @@ mod tests {
|
||||
assert_eq!(warnings.len(), 1);
|
||||
assert!(warnings[0].contains(&format!("object {}", original.id.0)), "{:?}", warnings);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_warning_names_the_object_by_its_id_and_its_name() {
|
||||
let mut doc = Document::new(100.0, 100.0);
|
||||
doc.raster_effects_ppi = 300.0;
|
||||
let mut named = Node::group(NodeId(7), vec![]);
|
||||
named.name = Some("Logo".into());
|
||||
let unnamed = Node::group(NodeId(8), vec![]);
|
||||
let mut report = FlattenReport::new(Which::All, &doc);
|
||||
report.record(&named, &image(72.0));
|
||||
report.record(&unnamed, &image(150.0));
|
||||
assert_eq!(
|
||||
report.warnings(),
|
||||
[
|
||||
"raster effects on object 7 (Logo): requested 300.0 ppi, achieved 72.0 ppi due to the 64 million pixel cap",
|
||||
"raster effects on object 8: requested 300.0 ppi, achieved 150.0 ppi due to the 64 million pixel cap",
|
||||
]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
+196
-75
@@ -4,7 +4,7 @@ use std::collections::{BTreeSet, HashSet};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_color::Paint;
|
||||
use vectorcraft_doc::{Document, LockedArtboards, Node, NodeId, NodeKind};
|
||||
use vectorcraft_doc::{AnchorRef, Document, LockedArtboards, Node, NodeId, NodeKind, Selection};
|
||||
use vectorcraft_tools::builder::is_live_paint;
|
||||
|
||||
use super::object::can_align;
|
||||
@@ -308,24 +308,30 @@ pub(crate) fn selectable(d: &Document, iso: Option<NodeId>) -> Vec<NodeId> {
|
||||
/// them, leaving out every hidden or locked object with what it holds. `f` returns whether to
|
||||
/// visit the objects inside the one it is given.
|
||||
pub(crate) fn walk_selectable(d: &Document, iso: Option<NodeId>, mut f: impl FnMut(&Node) -> bool) {
|
||||
fn inside(n: &Node, f: &mut impl FnMut(&Node) -> bool) {
|
||||
if n.visible && !n.locked && f(n) {
|
||||
walk_selectable_in(d, iso, |n, _| f(n));
|
||||
}
|
||||
|
||||
/// [`walk_selectable`], handing `f` each object with the node that holds it in the tree: its
|
||||
/// layer, sublayer, group or other container, or `None` for a top-level layer.
|
||||
fn walk_selectable_in(d: &Document, iso: Option<NodeId>, mut f: impl FnMut(&Node, Option<&Node>) -> bool) {
|
||||
fn inside(n: &Node, parent: Option<&Node>, f: &mut impl FnMut(&Node, Option<&Node>) -> bool) {
|
||||
if n.visible && !n.locked && f(n, parent) {
|
||||
for c in n.children().into_iter().flatten() {
|
||||
inside(c, f);
|
||||
inside(c, Some(n), f);
|
||||
}
|
||||
}
|
||||
}
|
||||
fn find(n: &Node, tops: &BTreeSet<NodeId>, f: &mut impl FnMut(&Node) -> bool) {
|
||||
fn find(n: &Node, parent: Option<&Node>, tops: &BTreeSet<NodeId>, f: &mut impl FnMut(&Node, Option<&Node>) -> bool) {
|
||||
if tops.contains(&n.id) {
|
||||
return inside(n, f);
|
||||
return inside(n, parent, f);
|
||||
}
|
||||
for c in n.children().into_iter().flatten() {
|
||||
find(c, tops, f);
|
||||
find(c, Some(n), tops, f);
|
||||
}
|
||||
}
|
||||
let tops: BTreeSet<NodeId> = selectable(d, iso).into_iter().collect();
|
||||
for l in &d.layers {
|
||||
find(l, &tops, &mut f);
|
||||
find(l, None, &tops, &mut f);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -923,52 +929,145 @@ fn anchors_many(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
None if bool_or(p, "add", false) => "add",
|
||||
None => "set",
|
||||
};
|
||||
s.select(|d, sel| {
|
||||
if mode == "set" {
|
||||
sel.clear();
|
||||
}
|
||||
for (id, refs) in items {
|
||||
// A segment pick's endpoints aren't selected anchors: start from none of them.
|
||||
let segment_pick = sel.segments.remove(&id).is_some();
|
||||
let all: BTreeSet<(usize, usize)> =
|
||||
d.node(id).and_then(|n| n.path_data()).map(|p| p.anchors().map(|(s, i, _)| (s, i)).collect()).unwrap_or_default();
|
||||
// Anything but a path is selected, toggled or deselected as a whole.
|
||||
if all.is_empty() {
|
||||
match mode {
|
||||
"toggle" => sel.toggle(id),
|
||||
"subtract" => sel.remove(id),
|
||||
_ => sel.add(id),
|
||||
}
|
||||
continue;
|
||||
}
|
||||
// From the anchors selected now (all of them for a path selected as a whole).
|
||||
let now = match sel.partial(id) {
|
||||
_ if segment_pick => BTreeSet::new(),
|
||||
Some(a) => a.clone(),
|
||||
None if sel.contains(id) => all.clone(),
|
||||
None => BTreeSet::new(),
|
||||
};
|
||||
let refs: BTreeSet<(usize, usize)> = refs.intersection(&all).copied().collect();
|
||||
let next: BTreeSet<(usize, usize)> = match mode {
|
||||
"toggle" => now.symmetric_difference(&refs).copied().collect(),
|
||||
"subtract" => now.difference(&refs).copied().collect(),
|
||||
_ => now.union(&refs).copied().collect(),
|
||||
};
|
||||
if next.is_empty() {
|
||||
sel.remove(id);
|
||||
continue;
|
||||
}
|
||||
sel.add(id);
|
||||
if next.len() < all.len() {
|
||||
sel.anchors.insert(id, next);
|
||||
} else {
|
||||
sel.anchors.remove(&id);
|
||||
}
|
||||
}
|
||||
})?;
|
||||
s.select(|d, sel| select_anchor_items(d, sel, items, mode))?;
|
||||
ok()
|
||||
}
|
||||
|
||||
/// `select.anchorsMany`'s change to `sel`: each item in order, with the selected objects kept in a
|
||||
/// [`Members`] map while the items run, so that an item's membership check and change don't go
|
||||
/// through `sel.objects`.
|
||||
fn select_anchor_items(d: &Document, sel: &mut Selection, items: Vec<(NodeId, BTreeSet<AnchorRef>)>, mode: &str) {
|
||||
if mode == "set" {
|
||||
sel.clear();
|
||||
}
|
||||
if items.is_empty() {
|
||||
return;
|
||||
}
|
||||
let mut members = Members::of(sel);
|
||||
for (id, refs) in items {
|
||||
// A segment pick's endpoints aren't selected anchors: start from none of them.
|
||||
let segment_pick = sel.segments.remove(&id).is_some();
|
||||
let all: BTreeSet<AnchorRef> =
|
||||
d.node(id).and_then(|n| n.path_data()).map(|p| p.anchors().map(|(s, i, _)| (s, i)).collect()).unwrap_or_default();
|
||||
// Anything but a path is selected, toggled or deselected as a whole.
|
||||
if all.is_empty() {
|
||||
match mode {
|
||||
"toggle" => members.toggle(sel, id),
|
||||
"subtract" => members.remove(sel, id),
|
||||
_ => members.add(sel, id),
|
||||
}
|
||||
continue;
|
||||
}
|
||||
// From the anchors selected now (all of them for a path selected as a whole).
|
||||
let now = match sel.partial(id) {
|
||||
_ if segment_pick => BTreeSet::new(),
|
||||
Some(a) => a.clone(),
|
||||
None if members.contains(id) => all.clone(),
|
||||
None => BTreeSet::new(),
|
||||
};
|
||||
let refs: BTreeSet<AnchorRef> = refs.intersection(&all).copied().collect();
|
||||
let next: BTreeSet<AnchorRef> = match mode {
|
||||
"toggle" => now.symmetric_difference(&refs).copied().collect(),
|
||||
"subtract" => now.difference(&refs).copied().collect(),
|
||||
_ => now.union(&refs).copied().collect(),
|
||||
};
|
||||
if next.is_empty() {
|
||||
members.remove(sel, id);
|
||||
continue;
|
||||
}
|
||||
members.add(sel, id);
|
||||
if next.len() < all.len() {
|
||||
sel.anchors.insert(id, next);
|
||||
} else {
|
||||
sel.anchors.remove(&id);
|
||||
}
|
||||
}
|
||||
members.finish(sel);
|
||||
}
|
||||
|
||||
/// The selected objects of a [`Selection`] while [`select_anchor_items`] changes them. Each
|
||||
/// selected id maps to the activation that selected it: 0 for the objects selected before, and
|
||||
/// a new number for each later [`Members::add`] of an unselected id, which `added` lists in order.
|
||||
/// [`Members::finish`] writes them back to `objects`.
|
||||
struct Members {
|
||||
live: std::collections::HashMap<NodeId, usize>,
|
||||
added: Vec<(NodeId, usize)>,
|
||||
removed: bool,
|
||||
}
|
||||
|
||||
impl Members {
|
||||
fn of(sel: &Selection) -> Self {
|
||||
count_objects_walk();
|
||||
Self { live: sel.objects.iter().map(|id| (*id, 0)).collect(), added: Vec::new(), removed: false }
|
||||
}
|
||||
|
||||
fn contains(&self, id: NodeId) -> bool {
|
||||
self.live.contains_key(&id)
|
||||
}
|
||||
|
||||
/// [`Selection::add`]: clears what any selection change clears, and selects `id` at the end
|
||||
/// unless it is selected.
|
||||
fn add(&mut self, sel: &mut Selection, id: NodeId) {
|
||||
sel.target = None;
|
||||
sel.slices.clear();
|
||||
sel.symbol_part = None;
|
||||
sel.on_path_member = None;
|
||||
if let std::collections::hash_map::Entry::Vacant(e) = self.live.entry(id) {
|
||||
let activation = self.added.len() + 1;
|
||||
e.insert(activation);
|
||||
self.added.push((id, activation));
|
||||
}
|
||||
}
|
||||
|
||||
/// [`Selection::remove`]: clears what any selection change clears, and deselects `id` with
|
||||
/// its anchors, segments, and the key or key anchor it is.
|
||||
fn remove(&mut self, sel: &mut Selection, id: NodeId) {
|
||||
sel.target = None;
|
||||
sel.slices.clear();
|
||||
sel.symbol_part = None;
|
||||
sel.on_path_member = None;
|
||||
if self.live.remove(&id).is_some() {
|
||||
self.removed = true;
|
||||
}
|
||||
sel.anchors.remove(&id);
|
||||
sel.segments.remove(&id);
|
||||
if sel.key == Some(id) {
|
||||
sel.key = None;
|
||||
}
|
||||
if sel.key_anchor.is_some_and(|(k, _)| k == id) {
|
||||
sel.key_anchor = None;
|
||||
}
|
||||
}
|
||||
|
||||
/// [`Selection::toggle`].
|
||||
fn toggle(&mut self, sel: &mut Selection, id: NodeId) {
|
||||
if self.contains(id) { self.remove(sel, id) } else { self.add(sel, id) }
|
||||
}
|
||||
|
||||
/// Writes the selected objects to `sel.objects`: the slots of the objects selected before and
|
||||
/// still selected by that activation, in their order, then the ids selected since and still
|
||||
/// selected by the activation that added them, in the order they were added.
|
||||
fn finish(self, sel: &mut Selection) {
|
||||
if self.removed {
|
||||
count_objects_walk();
|
||||
sel.objects.retain(|id| self.live.get(id) == Some(&0));
|
||||
}
|
||||
sel.objects.extend(self.added.into_iter().filter(|(id, n)| self.live.get(id) == Some(n)).map(|(id, _)| id));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
thread_local! {
|
||||
/// Tests: how many walks [`select_anchor_items`] made over the selected objects on this thread.
|
||||
pub(crate) static OBJECTS_WALKS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||||
}
|
||||
|
||||
/// Tests: count one walk over the selected objects.
|
||||
fn count_objects_walk() {
|
||||
#[cfg(test)]
|
||||
OBJECTS_WALKS.set(OBJECTS_WALKS.get() + 1);
|
||||
}
|
||||
|
||||
/// Select › Same › Fill/Stroke Color: is `a` the same colour as `b`? Tints of one global or spot
|
||||
/// swatch are, unless `tint` (General › Select Same Tint %) asks for the same tint too.
|
||||
pub(crate) fn same_paint(a: &Paint, b: &Paint, tint: bool) -> bool {
|
||||
@@ -998,7 +1097,9 @@ fn select_color(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
return Err(bad(C, "give `fill`, `stroke` or both"));
|
||||
}
|
||||
let reads_as = |paint: Paint, hex: Option<&str>| hex.is_none_or(|h| paint.color().is_some_and(|c| c.to_hex() == h));
|
||||
select_where(s, C, p, |d, n| paint_reported(d, n) && reads_as(fill_of(n), fill.as_deref()) && reads_as(stroke_of(n).0, stroke.as_deref()))
|
||||
select_where(s, C, p, |_, n, parent| {
|
||||
paint_reported(n, parent) && reads_as(fill_of(n), fill.as_deref()) && reads_as(stroke_of(n).0, stroke.as_deref())
|
||||
})
|
||||
}
|
||||
|
||||
/// The longest note, in bytes, that Select by Note searches for.
|
||||
@@ -1119,11 +1220,11 @@ fn fold_case(c: char) -> impl Iterator<Item = char> {
|
||||
c.to_lowercase().map(|l| if l == 'ς' { 'σ' } else { l })
|
||||
}
|
||||
|
||||
/// Does `document.inspect` report a fill and stroke for `n`? A compound path's are its own, though
|
||||
/// it holds its members, and its members report none.
|
||||
fn paint_reported(d: &Document, n: &Node) -> bool {
|
||||
/// Does `document.inspect` report a fill and stroke for `n`, held by `parent`? A compound path's
|
||||
/// are its own, though it holds its members, and its members report none.
|
||||
fn paint_reported(n: &Node, parent: Option<&Node>) -> bool {
|
||||
let compound = |n: &Node| matches!(n.kind, NodeKind::Compound { .. });
|
||||
compound(n) || (!n.is_container() && !d.parent_of(n.id).and_then(|p| d.node(p)).is_some_and(compound))
|
||||
compound(n) || (!n.is_container() && !parent.is_some_and(compound))
|
||||
}
|
||||
|
||||
/// The object Select > Same compares the others with, and whether isolation mode is inside a
|
||||
@@ -1160,30 +1261,30 @@ fn same_fill(s: &mut Session, cmd: &str, eq: impl Fn(&Node, &Node) -> bool) -> R
|
||||
fn same_in(s: &mut Session, cmd: &str, live_paint: bool, eq: impl Fn(&Node, &Node) -> bool) -> Result<Value> {
|
||||
let st = s.doc()?;
|
||||
let (refn, members) = same_reference(st, cmd)?;
|
||||
let group = live_paint_group(&st.doc, refn.id);
|
||||
let group = live_paint_group(st.doc.parent_of(refn.id).and_then(|p| st.doc.node(p)));
|
||||
let refn = refn.clone();
|
||||
select_where(s, cmd, &json!({}), |d, n| {
|
||||
(!live_paint || live_paint_group(d, n.id) == group) && (if members { !n.is_container() } else { paint_reported(d, n) }) && eq(n, &refn)
|
||||
})
|
||||
select_where(s, cmd, &json!({}), |_, n, parent| same_candidate(n, parent, live_paint, group, members) && eq(n, &refn))
|
||||
}
|
||||
|
||||
/// The Live Paint group `id` is a face or edge of.
|
||||
fn live_paint_group(d: &Document, id: NodeId) -> Option<NodeId> {
|
||||
d.parent_of(id).filter(|p| d.node(*p).is_some_and(is_live_paint))
|
||||
/// Whether Select > Same compares `n`, held by `parent`, with its reference: with `live_paint`, only
|
||||
/// when `n` is a face or edge of the Live Paint group `group` (or of none, for `None`); in
|
||||
/// isolation mode inside a compound path (`members`), any object that is not a container;
|
||||
/// otherwise one that [`paint_reported`] accepts.
|
||||
fn same_candidate(n: &Node, parent: Option<&Node>, live_paint: bool, group: Option<NodeId>, members: bool) -> bool {
|
||||
(!live_paint || live_paint_group(parent) == group) && (if members { !n.is_container() } else { paint_reported(n, parent) })
|
||||
}
|
||||
|
||||
/// The Live Paint group an object held by `parent` is a face or edge of.
|
||||
fn live_paint_group(parent: Option<&Node>) -> Option<NodeId> {
|
||||
parent.filter(|p| is_live_paint(p)).map(|p| p.id)
|
||||
}
|
||||
|
||||
/// Select the objects [`walk_selectable`] visits that `f` accepts (not looking inside accepted
|
||||
/// ones); Select > Reselect repeats `cmd` with `p`.
|
||||
pub(crate) fn select_where(s: &mut Session, cmd: &str, p: &Value, f: impl Fn(&Document, &Node) -> bool) -> Result<Value> {
|
||||
/// ones); `f` is given each object with the node that holds it. Select > Reselect repeats `cmd`
|
||||
/// with `p`.
|
||||
pub(crate) fn select_where(s: &mut Session, cmd: &str, p: &Value, f: impl Fn(&Document, &Node, Option<&Node>) -> bool) -> Result<Value> {
|
||||
let st = s.doc()?;
|
||||
let mut ids = vec![];
|
||||
walk_selectable(&st.doc, st.isolation, |n| {
|
||||
if f(&st.doc, n) {
|
||||
ids.push(n.id);
|
||||
return false;
|
||||
}
|
||||
true
|
||||
});
|
||||
let ids = matching(&st.doc, st.isolation, |n, parent| f(&st.doc, n, parent));
|
||||
let from = st.selection.objects.clone();
|
||||
s.select(|_, sel| sel.set(ids.iter().copied()))?;
|
||||
let st = s.doc_mut()?;
|
||||
@@ -1192,12 +1293,26 @@ pub(crate) fn select_where(s: &mut Session, cmd: &str, p: &Value, f: impl Fn(&Do
|
||||
Ok(json!({ "count": st.selection.objects.len() }))
|
||||
}
|
||||
|
||||
/// The objects [`walk_selectable`] visits that `f` accepts, in paint order, not looking inside
|
||||
/// accepted ones. `f` is given each object with the node that holds it.
|
||||
fn matching(d: &Document, iso: Option<NodeId>, f: impl Fn(&Node, Option<&Node>) -> bool) -> Vec<NodeId> {
|
||||
let mut ids = vec![];
|
||||
walk_selectable_in(d, iso, |n, parent| {
|
||||
if f(n, parent) {
|
||||
ids.push(n.id);
|
||||
return false;
|
||||
}
|
||||
true
|
||||
});
|
||||
ids
|
||||
}
|
||||
|
||||
fn same_graphic_style(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
let cmd = "select.same.graphicStyle";
|
||||
let st = s.doc()?;
|
||||
let (refn, _) = same_reference(st, cmd)?;
|
||||
let id = super::style::linked_style(&st.doc, refn).map(|g| g.id).ok_or_else(|| bad(cmd, "the selection has no graphic style"))?;
|
||||
select_where(s, cmd, &json!({}), |d, n| n.extras().graphic_style == Some(id) && super::style::linked_style(d, n).is_some())
|
||||
select_where(s, cmd, &json!({}), |d, n, _| n.extras().graphic_style == Some(id) && super::style::linked_style(d, n).is_some())
|
||||
}
|
||||
|
||||
/// An appearance attribute Select > Same > Appearance Attribute matches.
|
||||
@@ -1221,7 +1336,7 @@ fn same_attribute(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Attribute::Item(ap.items.iter().rev().find(|i| i.is_fill()).cloned().ok_or_else(|| bad(cmd, "the object has no fill, stroke or effect"))?)
|
||||
}
|
||||
};
|
||||
select_where(s, cmd, p, |_, n| match &attr {
|
||||
select_where(s, cmd, p, |_, n, _| match &attr {
|
||||
Attribute::Item(it) => n.appearance.items.contains(it),
|
||||
Attribute::Effect(e) => n.appearance.effects.iter().any(|x| x.id == e.id && x.params == e.params),
|
||||
})
|
||||
@@ -1280,3 +1395,9 @@ fn not_pixel_aligned(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
s.select(|_, sel| sel.set(ids))?;
|
||||
Ok(json!({ "count": s.doc()?.selection.objects.len() }))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod same_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
@@ -0,0 +1,433 @@
|
||||
//! Select > Same and Select by Color through [`walk_selectable_in`], which hands each object the
|
||||
//! node that holds it, against copies of the walk and the tests that looked each object's parent up
|
||||
//! by its id.
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
|
||||
|
||||
use super::{fill_of, is_live_paint, matching, same_candidate, same_paint, same_reference, selectable, stroke_of, walk_selectable_in};
|
||||
use crate::Session;
|
||||
|
||||
/// `walk_selectable` as it was before it handed each object its parent.
|
||||
fn walk_by_id(d: &Document, iso: Option<NodeId>, mut f: impl FnMut(&Node) -> bool) {
|
||||
fn inside(n: &Node, f: &mut impl FnMut(&Node) -> bool) {
|
||||
if n.visible && !n.locked && f(n) {
|
||||
for c in n.children().into_iter().flatten() {
|
||||
inside(c, f);
|
||||
}
|
||||
}
|
||||
}
|
||||
fn find(n: &Node, tops: &BTreeSet<NodeId>, f: &mut impl FnMut(&Node) -> bool) {
|
||||
if tops.contains(&n.id) {
|
||||
return inside(n, f);
|
||||
}
|
||||
for c in n.children().into_iter().flatten() {
|
||||
find(c, tops, f);
|
||||
}
|
||||
}
|
||||
let tops: BTreeSet<NodeId> = selectable(d, iso).into_iter().collect();
|
||||
for l in &d.layers {
|
||||
find(l, &tops, &mut f);
|
||||
}
|
||||
}
|
||||
|
||||
/// `paint_reported` as it was, looking up `n`'s parent by its id.
|
||||
fn paint_reported_by_id(d: &Document, n: &Node) -> bool {
|
||||
let compound = |n: &Node| matches!(n.kind, NodeKind::Compound { .. });
|
||||
compound(n) || (!n.is_container() && !d.parent_of(n.id).and_then(|p| d.node(p)).is_some_and(compound))
|
||||
}
|
||||
|
||||
/// `live_paint_group` as it was, looking up the parent of `id`.
|
||||
fn live_paint_group_by_id(d: &Document, id: NodeId) -> Option<NodeId> {
|
||||
d.parent_of(id).filter(|p| d.node(*p).is_some_and(is_live_paint))
|
||||
}
|
||||
|
||||
/// The objects `select_where`'s loop took before the walk handed each object its parent.
|
||||
fn matching_by_id(d: &Document, iso: Option<NodeId>, f: impl Fn(&Document, &Node) -> bool) -> Vec<NodeId> {
|
||||
let mut ids = vec![];
|
||||
walk_by_id(d, iso, |n| {
|
||||
if f(d, n) {
|
||||
ids.push(n.id);
|
||||
return false;
|
||||
}
|
||||
true
|
||||
});
|
||||
ids
|
||||
}
|
||||
|
||||
/// The objects `same_in` took before the walk handed each object its parent.
|
||||
fn same_by_id(d: &Document, iso: Option<NodeId>, refn: &Node, members: bool, live_paint: bool, eq: impl Fn(&Node, &Node) -> bool) -> Vec<NodeId> {
|
||||
let group = live_paint_group_by_id(d, refn.id);
|
||||
matching_by_id(d, iso, |d, n| {
|
||||
(!live_paint || live_paint_group_by_id(d, n.id) == group)
|
||||
&& (if members { !n.is_container() } else { paint_reported_by_id(d, n) })
|
||||
&& eq(n, refn)
|
||||
})
|
||||
}
|
||||
|
||||
/// The objects `same_in` takes now.
|
||||
fn same_now(d: &Document, iso: Option<NodeId>, refn: &Node, members: bool, live_paint: bool, eq: impl Fn(&Node, &Node) -> bool) -> Vec<NodeId> {
|
||||
let group = super::live_paint_group(d.parent_of(refn.id).and_then(|p| d.node(p)));
|
||||
matching(d, iso, |n, parent| same_candidate(n, parent, live_paint, group, members) && eq(n, refn))
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn run(s: &mut Session, cmd: &str, p: Value) -> Value {
|
||||
s.execute(cmd, &p).unwrap_or_else(|e| panic!("`{cmd}` {p} failed: {e}"))
|
||||
}
|
||||
|
||||
fn id(v: &Value) -> NodeId {
|
||||
NodeId(v["id"].as_u64().unwrap_or_else(|| panic!("no id in {v}")))
|
||||
}
|
||||
|
||||
fn sel(s: &mut Session, ids: &[NodeId]) {
|
||||
run(s, "select.set", json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()}));
|
||||
}
|
||||
|
||||
/// A 10 × 10 rectangle at (`x`, `y`) filled with `hex`.
|
||||
fn rect(s: &mut Session, x: f64, y: f64, hex: &str) -> NodeId {
|
||||
let r = id(&run(s, "shape.rectangle", json!({"x": x, "y": y, "width": 10.0, "height": 10.0})));
|
||||
run(s, "paint.setFill", json!({"ids": [r.0], "color": hex}));
|
||||
r
|
||||
}
|
||||
|
||||
/// A compound path of three rectangles at `y`, filled with `hex` → the compound path and its
|
||||
/// member paths.
|
||||
fn compound(s: &mut Session, y: f64, hex: &str) -> (NodeId, Vec<NodeId>) {
|
||||
let members: Vec<NodeId> = [0.0, 20.0, 40.0].map(|x| rect(s, 300.0 + x, y, hex)).into();
|
||||
sel(s, &members);
|
||||
let c = id(&run(s, "object.compoundPath.make", json!({})));
|
||||
run(s, "paint.setFill", json!({"ids": [c.0], "color": hex}));
|
||||
(c, members)
|
||||
}
|
||||
|
||||
/// A Live Paint group of two overlapping squares at `y`, its left face red, its middle face blue and
|
||||
/// its right face red → the group and its faces.
|
||||
fn live_paint(s: &mut Session, y: f64) -> (NodeId, Vec<NodeId>) {
|
||||
let a = id(&run(s, "shape.rectangle", json!({"x": 0.0, "y": y, "width": 100.0, "height": 100.0})));
|
||||
let b = id(&run(s, "shape.rectangle", json!({"x": 50.0, "y": y, "width": 100.0, "height": 100.0})));
|
||||
sel(s, &[a, b]);
|
||||
let g = id(&run(s, "livePaint.make", json!({})));
|
||||
let faces = [(25.0, "#ff0000"), (75.0, "#0000ff"), (125.0, "#ff0000")]
|
||||
.map(|(x, hex)| NodeId(run(s, "livePaint.fill", json!({"group": g.0, "point": [x, y + 50.0], "color": hex}))["face"].as_u64().unwrap()))
|
||||
.into();
|
||||
(g, faces)
|
||||
}
|
||||
|
||||
/// The objects of [`rich`] that tests pick from.
|
||||
struct Rich {
|
||||
plain: Vec<NodeId>,
|
||||
compound: NodeId,
|
||||
members: Vec<NodeId>,
|
||||
group: NodeId,
|
||||
live_paint: NodeId,
|
||||
faces: Vec<NodeId>,
|
||||
sublayer: NodeId,
|
||||
}
|
||||
|
||||
/// A document with red and blue rectangles, a compound path, a group with a hidden and a locked
|
||||
/// rectangle, a locked group, a Live Paint group, a sublayer holding a rectangle and a second
|
||||
/// compound path, and a hidden and a locked layer with a red rectangle each.
|
||||
fn rich() -> (Session, Rich) {
|
||||
let mut s = Session::new();
|
||||
run(&mut s, "file.new", json!({"width": 800, "height": 600}));
|
||||
let layer = s.doc().unwrap().doc.layers[0].id;
|
||||
let mut plain = vec![rect(&mut s, 0.0, 0.0, "#ff0000"), rect(&mut s, 20.0, 0.0, "#ff0000"), rect(&mut s, 40.0, 0.0, "#0000ff")];
|
||||
let (compound_id, members) = compound(&mut s, 0.0, "#ff0000");
|
||||
let [in_group, hidden, locked] = [0.0, 20.0, 40.0].map(|x| rect(&mut s, x, 200.0, "#ff0000"));
|
||||
let blue = rect(&mut s, 60.0, 200.0, "#0000ff");
|
||||
sel(&mut s, &[in_group, hidden, locked, blue]);
|
||||
let group = id(&run(&mut s, "object.group", json!({})));
|
||||
run(&mut s, "layer.setProps", json!({"id": hidden.0, "visible": false}));
|
||||
run(&mut s, "layer.setProps", json!({"id": locked.0, "locked": true}));
|
||||
let in_locked = rect(&mut s, 100.0, 200.0, "#ff0000");
|
||||
sel(&mut s, &[in_locked]);
|
||||
let locked_group = id(&run(&mut s, "object.group", json!({})));
|
||||
run(&mut s, "layer.setProps", json!({"id": locked_group.0, "locked": true}));
|
||||
let (live_paint_id, faces) = live_paint(&mut s, 300.0);
|
||||
plain.extend([in_group, blue]);
|
||||
let sublayer = id(&run(&mut s, "layer.newSublayer", json!({"parent": layer.0})));
|
||||
plain.push(rect(&mut s, 0.0, 500.0, "#ff0000"));
|
||||
compound(&mut s, 500.0, "#0000ff");
|
||||
for prop in ["visible", "locked"] {
|
||||
let l = id(&run(&mut s, "layer.new", json!({"top": true})));
|
||||
rect(&mut s, 200.0, 500.0, "#ff0000");
|
||||
run(&mut s, "layer.setProps", json!({"id": l.0, prop: prop == "locked"}));
|
||||
}
|
||||
let rich = Rich { plain, compound: compound_id, members, group, live_paint: live_paint_id, faces, sublayer };
|
||||
(s, rich)
|
||||
}
|
||||
|
||||
/// The isolation scopes to try: none, the group, the compound path, and the Live Paint group.
|
||||
fn scopes(r: &Rich) -> [Option<NodeId>; 4] {
|
||||
[None, Some(r.group), Some(r.compound), Some(r.live_paint)]
|
||||
}
|
||||
|
||||
/// Isolate `iso`, leaving isolation mode first.
|
||||
fn isolate(s: &mut Session, iso: Option<NodeId>) {
|
||||
if s.doc().unwrap().isolation.is_some() {
|
||||
run(s, "object.exitIsolation", json!({}));
|
||||
}
|
||||
if let Some(i) = iso {
|
||||
run(s, "object.isolate", json!({"id": i.0}));
|
||||
assert_eq!(s.doc().unwrap().isolation, Some(i));
|
||||
}
|
||||
}
|
||||
|
||||
/// The walk visits the objects it visited before, in the same order and with the same objects left
|
||||
/// out, and hands each the node that `Document::parent_of` names for it.
|
||||
#[test]
|
||||
fn the_walk_hands_each_object_the_node_that_holds_it() {
|
||||
let (mut s, r) = rich();
|
||||
// Look inside everything, and inside every other object only.
|
||||
let deeper: [fn(&Node) -> bool; 2] = [|_| true, |n| n.id.0 % 2 == 0];
|
||||
for iso in scopes(&r) {
|
||||
isolate(&mut s, iso);
|
||||
let st = s.doc().unwrap();
|
||||
let d = &st.doc;
|
||||
for f in deeper {
|
||||
let mut before = vec![];
|
||||
walk_by_id(d, st.isolation, |n| {
|
||||
before.push((n.id, d.parent_of(n.id)));
|
||||
f(n)
|
||||
});
|
||||
let mut now = vec![];
|
||||
walk_selectable_in(d, st.isolation, |n, parent| {
|
||||
now.push((n.id, parent.map(|p| p.id)));
|
||||
f(n)
|
||||
});
|
||||
assert!(!now.is_empty(), "isolating {iso:?}");
|
||||
assert_eq!(now, before, "isolating {iso:?}");
|
||||
}
|
||||
}
|
||||
// Every face, member path and the sublayer's art were visited somewhere above.
|
||||
let st = s.doc().unwrap();
|
||||
assert!(r.faces.iter().chain(&r.members).all(|f| st.doc.node(*f).is_some()));
|
||||
assert!(st.doc.node(r.sublayer).is_some_and(|n| n.is_layer()));
|
||||
}
|
||||
|
||||
/// Select > Same and Select by Color select the objects they selected before, in the same order,
|
||||
/// with the same reply and the same Select > Reselect state, from every kind of reference object
|
||||
/// and in every isolation scope.
|
||||
#[test]
|
||||
fn select_same_takes_the_objects_it_took_when_it_looked_up_parents() {
|
||||
type Eq = fn(&Node, &Node) -> bool;
|
||||
let fill: Eq = |a, b| same_paint(&fill_of(a), &fill_of(b), false);
|
||||
let stroke: Eq = |a, b| same_paint(&stroke_of(a).0, &stroke_of(b).0, false);
|
||||
let commands: [(&str, bool, Eq); 6] = [
|
||||
("select.same.fillColor", true, fill),
|
||||
("select.same.fillAndStroke", true, |a, b| {
|
||||
same_paint(&fill_of(a), &fill_of(b), false) && same_paint(&stroke_of(a).0, &stroke_of(b).0, false)
|
||||
}),
|
||||
("select.same.strokeColor", false, stroke),
|
||||
("select.same.opacity", false, |a, b| (a.opacity - b.opacity).abs() < 1e-6),
|
||||
("select.same.blendingMode", false, |a, b| a.blend == b.blend),
|
||||
("select.same.shapeType", false, |a, b| a.kind_label() == b.kind_label()),
|
||||
];
|
||||
let (mut s, r) = rich();
|
||||
assert!(!s.prefs.select_same_tint_percent);
|
||||
let froms: Vec<NodeId> = r.plain.iter().chain(&r.members).chain(&r.faces).copied().chain([r.compound]).collect();
|
||||
let mut checked = 0;
|
||||
for iso in scopes(&r) {
|
||||
isolate(&mut s, iso);
|
||||
for from in &froms {
|
||||
for (cmd, live_paint, eq) in commands {
|
||||
// An object outside the isolated one may not be selectable; the selection then
|
||||
// stays, and both sides compare with what it holds.
|
||||
let _ = s.execute("select.set", &json!({"ids": [from.0]}));
|
||||
let st = s.doc().unwrap();
|
||||
let Ok((refn, members)) = same_reference(st, cmd) else {
|
||||
assert!(s.execute(cmd, &json!({})).is_err(), "{cmd} from {from:?} isolating {iso:?}");
|
||||
continue;
|
||||
};
|
||||
let refn = refn.clone();
|
||||
let expected = same_by_id(&st.doc, st.isolation, &refn, members, live_paint, eq);
|
||||
assert_eq!(same_now(&st.doc, st.isolation, &refn, members, live_paint, eq), expected, "{cmd} from {from:?} isolating {iso:?}");
|
||||
let before = st.selection.objects.clone();
|
||||
let reply = run(&mut s, cmd, json!({}));
|
||||
let st = s.doc().unwrap();
|
||||
assert_eq!(st.selection.objects, expected, "{cmd} from {from:?} isolating {iso:?}");
|
||||
assert_eq!(reply, json!({"count": expected.len()}));
|
||||
assert_eq!(st.last_selection_cmd, Some((cmd.to_string(), json!({}), before)));
|
||||
checked += 1;
|
||||
}
|
||||
}
|
||||
for hex in ["#ff0000", "#0000ff"] {
|
||||
let st = s.doc().unwrap();
|
||||
let reads_as = |n: &Node| fill_of(n).color().is_some_and(|c| c.to_hex() == hex);
|
||||
let expected = matching_by_id(&st.doc, st.isolation, |d, n| paint_reported_by_id(d, n) && reads_as(n));
|
||||
let p = json!({"fill": hex});
|
||||
let reply = run(&mut s, "select.color", p.clone());
|
||||
let st = s.doc().unwrap();
|
||||
assert_eq!(st.selection.objects, expected, "select.color {hex} isolating {iso:?}");
|
||||
assert_eq!(reply, json!({"count": expected.len()}));
|
||||
assert_eq!(st.last_selection_cmd.as_ref().map(|(c, p, _)| (c.as_str(), p)), Some(("select.color", &p)));
|
||||
}
|
||||
}
|
||||
// Most of the references can be selected in some scope.
|
||||
assert!(checked > froms.len() * commands.len(), "{checked} checks");
|
||||
}
|
||||
|
||||
/// In a damaged document that holds an id twice, the parent that decides whether an object is a
|
||||
/// member of a compound path or a face of a Live Paint group is the one that holds the object the
|
||||
/// walk is at, not the one that holds the id's first place in the tree.
|
||||
#[test]
|
||||
fn select_same_reads_the_parent_of_the_object_it_is_at() {
|
||||
for in_live_paint in [false, true] {
|
||||
let mut s = Session::new();
|
||||
run(&mut s, "file.new", json!({"width": 800, "height": 600}));
|
||||
let layer = s.doc().unwrap().doc.layers[0].id;
|
||||
let (_, inner) = if in_live_paint { live_paint(&mut s, 300.0) } else { compound(&mut s, 0.0, "#0000ff") };
|
||||
let from = rect(&mut s, 0.0, 0.0, "#ff0000");
|
||||
// A red rectangle above the others that has the id of a face or member path.
|
||||
let mut copy = s.doc().unwrap().doc.node(from).unwrap().clone();
|
||||
copy.id = inner[0];
|
||||
Arc::make_mut(&mut s.doc_mut().unwrap().doc).insert(Some(layer), usize::MAX, copy).unwrap();
|
||||
let mut commands = vec![("select.same.fillColor", json!({})), ("select.same.fillAndStroke", json!({}))];
|
||||
// Select by Color takes the red faces of a Live Paint group too, so it is tried on the
|
||||
// compound path only.
|
||||
if !in_live_paint {
|
||||
commands.push(("select.color", json!({"fill": "#ff0000"})));
|
||||
}
|
||||
for (cmd, p) in commands {
|
||||
sel(&mut s, &[from]);
|
||||
let reply = run(&mut s, cmd, p);
|
||||
assert_eq!(reply["count"], 2, "{cmd}, Live Paint: {in_live_paint}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A document of `n` objects on one layer: red and blue rectangles, one in 25 a compound path of
|
||||
/// three, and two Live Paint groups that hold one in 25 each as faces → the session, with the first
|
||||
/// rectangle selected.
|
||||
fn big(n: usize) -> Session {
|
||||
let mut s = Session::new();
|
||||
run(&mut s, "file.new", json!({"width": 800, "height": 600}));
|
||||
let (c, _) = compound(&mut s, 0.0, "#ff0000");
|
||||
let (g, _) = live_paint(&mut s, 300.0);
|
||||
let [red, blue] = ["#ff0000", "#0000ff"].map(|hex| rect(&mut s, 0.0, 0.0, hex));
|
||||
let mut d = Document::clone(&s.doc().unwrap().doc);
|
||||
let layer = d.layers[0].id;
|
||||
let template = |id: NodeId| d.node(id).unwrap().clone();
|
||||
let (c, g, red, blue) = (template(c), template(g), template(red), template(blue));
|
||||
fn renumber(n: &Node, d: &mut Document) -> Node {
|
||||
let mut n = n.clone();
|
||||
n.id = d.alloc_id();
|
||||
for c in n.children_mut().into_iter().flatten() {
|
||||
*c = Arc::new(renumber(c, d));
|
||||
}
|
||||
n
|
||||
}
|
||||
d.children_mut(Some(layer)).unwrap().clear();
|
||||
let faces: Vec<Arc<Node>> = g.children().into_iter().flatten().cloned().collect();
|
||||
for _ in 0..2 {
|
||||
let mut g = renumber(&g, &mut d);
|
||||
if let Some(ch) = g.children_mut() {
|
||||
ch.clear();
|
||||
for i in 0..n / 25 {
|
||||
ch.push(Arc::new(renumber(&faces[i % faces.len()], &mut d)));
|
||||
}
|
||||
}
|
||||
d.insert(Some(layer), usize::MAX, g).unwrap();
|
||||
}
|
||||
for i in 0..n - 2 * (n / 25) {
|
||||
let node = match i % 25 {
|
||||
0 => renumber(&c, &mut d),
|
||||
k if k % 2 == 0 => renumber(&red, &mut d),
|
||||
_ => renumber(&blue, &mut d),
|
||||
};
|
||||
d.insert(Some(layer), usize::MAX, node).unwrap();
|
||||
}
|
||||
let first = d.layers[0].children().unwrap().iter().find(|n| matches!(n.kind, NodeKind::Path { .. })).unwrap().id;
|
||||
s.add_document(d, None);
|
||||
sel(&mut s, &[first]);
|
||||
s
|
||||
}
|
||||
|
||||
/// The CPU time this thread has used, from Linux's scheduler statistics; `None` elsewhere.
|
||||
fn thread_cpu() -> Option<Duration> {
|
||||
let stat = std::fs::read_to_string("/proc/thread-self/schedstat").ok()?;
|
||||
stat.split_whitespace().next()?.parse().ok().map(Duration::from_nanos)
|
||||
}
|
||||
|
||||
/// The time `f` takes: this thread's CPU time where Linux reports it, otherwise the wall clock.
|
||||
fn time(f: impl FnOnce()) -> Duration {
|
||||
match thread_cpu() {
|
||||
Some(before) => {
|
||||
f();
|
||||
thread_cpu().map_or(Duration::ZERO, |after| after.saturating_sub(before))
|
||||
}
|
||||
None => {
|
||||
let start = Instant::now();
|
||||
f();
|
||||
start.elapsed()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn ms(d: Duration) -> f64 {
|
||||
d.as_secs_f64() * 1000.0
|
||||
}
|
||||
|
||||
/// Timings of Select > Same's search, by id lookups and with the walk's parents, on 5,000, 50,000
|
||||
/// and 200,000 objects, run in turn on the same document, 7 runs each. Ignored by default; it
|
||||
/// prints the median, fastest and slowest run and sets no bound on them:
|
||||
/// `cargo test --release -p vectorcraft-engine --lib select_same_perf -- --ignored --nocapture`.
|
||||
#[test]
|
||||
#[ignore = "a benchmark: run with --ignored --nocapture"]
|
||||
fn select_same_perf() {
|
||||
const RUNS: usize = 7;
|
||||
type Eq = fn(&Node, &Node) -> bool;
|
||||
let fill: Eq = |a, b| same_paint(&fill_of(a), &fill_of(b), false);
|
||||
let stroke: Eq = |a, b| same_paint(&stroke_of(a).0, &stroke_of(b).0, false);
|
||||
eprintln!("select_same_perf: {}", if thread_cpu().is_some() { "thread CPU time" } else { "wall clock" });
|
||||
eprintln!(
|
||||
"select_same_perf: {:>7} {:<12} {:>8} {:>26} {:>26}",
|
||||
"objects", "command", "selected", "by id ms (min-max)", "walk parents ms (min-max)"
|
||||
);
|
||||
for n in [5_000, 50_000, 200_000] {
|
||||
let s = big(n);
|
||||
let st = s.doc().unwrap();
|
||||
let (d, iso) = (&st.doc, st.isolation);
|
||||
let objects = {
|
||||
let mut k = 0;
|
||||
walk_selectable_in(d, iso, |_, _| {
|
||||
k += 1;
|
||||
true
|
||||
});
|
||||
k
|
||||
};
|
||||
for (cmd, live_paint, eq) in [("fillColor", true, fill), ("strokeColor", false, stroke)] {
|
||||
let (refn, members) = same_reference(st, cmd).unwrap();
|
||||
let (mut old, mut new) = (Vec::new(), Vec::new());
|
||||
let (mut a, mut b) = (vec![], vec![]);
|
||||
for run in 0..RUNS {
|
||||
// The two take turns going first.
|
||||
if run % 2 == 0 {
|
||||
old.push(time(|| a = std::hint::black_box(same_by_id(d, iso, refn, members, live_paint, eq))));
|
||||
new.push(time(|| b = std::hint::black_box(same_now(d, iso, refn, members, live_paint, eq))));
|
||||
} else {
|
||||
new.push(time(|| b = std::hint::black_box(same_now(d, iso, refn, members, live_paint, eq))));
|
||||
old.push(time(|| a = std::hint::black_box(same_by_id(d, iso, refn, members, live_paint, eq))));
|
||||
}
|
||||
assert_eq!(a, b, "{n} objects, {cmd}");
|
||||
}
|
||||
old.sort();
|
||||
new.sort();
|
||||
eprintln!(
|
||||
"select_same_perf: {objects:>7} {cmd:<12} {:>8} {:>10.3} ({:>6.3}-{:>7.3}) {:>10.3} ({:>6.3}-{:>7.3})",
|
||||
b.len(),
|
||||
ms(old[RUNS / 2]),
|
||||
ms(old[0]),
|
||||
ms(old[RUNS - 1]),
|
||||
ms(new[RUNS / 2]),
|
||||
ms(new[0]),
|
||||
ms(new[RUNS - 1]),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,286 @@
|
||||
//! `select.anchorsMany`'s item loop ([`select_anchor_items`]) against a loop that changes the
|
||||
//! selection one item at a time through [`Selection::add`], [`Selection::remove`] and
|
||||
//! [`Selection::toggle`].
|
||||
|
||||
use std::collections::{BTreeSet, HashSet};
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use vectorcraft_color::Color;
|
||||
use vectorcraft_doc::{AnchorRef, Document, NodeId, Selection, SymbolPart};
|
||||
use vectorcraft_geom::Rect;
|
||||
use vectorcraft_testkit::fixtures::DocBuilder;
|
||||
|
||||
use super::{OBJECTS_WALKS, select_anchor_items};
|
||||
|
||||
type Items = Vec<(NodeId, BTreeSet<AnchorRef>)>;
|
||||
|
||||
const MODES: [&str; 4] = ["set", "add", "toggle", "subtract"];
|
||||
|
||||
/// The item loop through `Selection`'s own methods, each of which goes through `objects`.
|
||||
fn item_by_item(d: &Document, sel: &mut Selection, items: Items, mode: &str) {
|
||||
if mode == "set" {
|
||||
sel.clear();
|
||||
}
|
||||
for (id, refs) in items {
|
||||
let segment_pick = sel.segments.remove(&id).is_some();
|
||||
let all: BTreeSet<AnchorRef> =
|
||||
d.node(id).and_then(|n| n.path_data()).map(|p| p.anchors().map(|(s, i, _)| (s, i)).collect()).unwrap_or_default();
|
||||
if all.is_empty() {
|
||||
match mode {
|
||||
"toggle" => sel.toggle(id),
|
||||
"subtract" => sel.remove(id),
|
||||
_ => sel.add(id),
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let now = match sel.partial(id) {
|
||||
_ if segment_pick => BTreeSet::new(),
|
||||
Some(a) => a.clone(),
|
||||
None if sel.contains(id) => all.clone(),
|
||||
None => BTreeSet::new(),
|
||||
};
|
||||
let refs: BTreeSet<AnchorRef> = refs.intersection(&all).copied().collect();
|
||||
let next: BTreeSet<AnchorRef> = match mode {
|
||||
"toggle" => now.symmetric_difference(&refs).copied().collect(),
|
||||
"subtract" => now.difference(&refs).copied().collect(),
|
||||
_ => now.union(&refs).copied().collect(),
|
||||
};
|
||||
if next.is_empty() {
|
||||
sel.remove(id);
|
||||
continue;
|
||||
}
|
||||
sel.add(id);
|
||||
if next.len() < all.len() {
|
||||
sel.anchors.insert(id, next);
|
||||
} else {
|
||||
sel.anchors.remove(&id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A document with `n` four-anchor rectangles and, after them, a group of two more → the
|
||||
/// rectangles' ids and the group's.
|
||||
fn doc(n: usize) -> (Document, Vec<NodeId>, NodeId) {
|
||||
let mut b = DocBuilder::new(2000.0, 2000.0);
|
||||
let rects = (0..n)
|
||||
.map(|i| {
|
||||
let (x, y) = ((i % 200) as f64 * 10.0, (i / 200) as f64 * 10.0);
|
||||
b.rect(Rect::new(x, y, x + 5.0, y + 5.0), Color::rgb(0.2, 0.4, 0.6), |_| {})
|
||||
})
|
||||
.collect();
|
||||
let black = Color::rgb(0.0, 0.0, 0.0);
|
||||
let kids = vec![b.rect_node(Rect::new(0.0, 0.0, 1.0, 1.0), black), b.rect_node(Rect::new(2.0, 0.0, 3.0, 1.0), black)];
|
||||
let group = b.group(kids, false);
|
||||
(b.build(), rects, group)
|
||||
}
|
||||
|
||||
fn anchors(refs: &[(usize, usize)]) -> BTreeSet<AnchorRef> {
|
||||
refs.iter().copied().collect()
|
||||
}
|
||||
|
||||
/// A selection with every field set: rectangles 0 to 4 and the group, rectangle 2 listed twice,
|
||||
/// partial anchors on 1 and 3, a segment pick on 4, rectangle 1 the key, a key anchor on 3, and a
|
||||
/// target, slices, guides, a key guide, new art, a symbol part and an on-path member.
|
||||
fn seeded(r: &[NodeId], group: NodeId) -> Selection {
|
||||
let mut s = Selection { objects: vec![r[0], r[1], r[2], r[3], group, r[2], r[4]], ..Selection::default() };
|
||||
s.anchors.insert(r[1], anchors(&[(0, 0), (0, 1)]));
|
||||
s.anchors.insert(r[3], anchors(&[(0, 2)]));
|
||||
s.anchors.insert(r[4], anchors(&[(0, 0), (0, 1)]));
|
||||
s.segments.insert(r[4], anchors(&[(0, 0)]));
|
||||
s.key = Some(r[1]);
|
||||
s.key_anchor = Some((r[3], (0, 2)));
|
||||
s.target = Some(r[0]);
|
||||
s.slices = vec![r[5]];
|
||||
s.guides = vec![r[6]];
|
||||
s.key_guide = Some(r[6]);
|
||||
s.new_art = Arc::new(HashSet::from([r[2]]));
|
||||
s.symbol_part = Some(SymbolPart { instance: r[0], path: vec![0] });
|
||||
s.on_path_member = Some(r[7]);
|
||||
s
|
||||
}
|
||||
|
||||
/// Item lists with repeated ids, removals followed by additions, the group, anchors outside a
|
||||
/// path, items that empty a path, and the empty list, then pseudo-random lists.
|
||||
fn item_streams(r: &[NodeId], group: NodeId) -> Vec<Items> {
|
||||
let all = [(0, 0), (0, 1), (0, 2), (0, 3)];
|
||||
let mut streams: Vec<Items> = vec![
|
||||
vec![],
|
||||
vec![(r[2], anchors(&[(0, 0)]))],
|
||||
vec![(r[2], anchors(&all)), (r[2], anchors(&all))],
|
||||
vec![(r[2], anchors(&all)), (r[5], anchors(&[(0, 1)])), (r[2], anchors(&[(0, 3)]))],
|
||||
vec![(group, anchors(&[])), (group, anchors(&[(0, 0)])), (group, anchors(&[]))],
|
||||
vec![(r[6], anchors(&[(0, 0)])), (r[6], anchors(&[(0, 0)])), (r[7], anchors(&[(0, 9), (3, 0)]))],
|
||||
vec![(r[1], anchors(&[(0, 0), (0, 1)])), (r[3], anchors(&[(0, 2)])), (r[1], anchors(&all)), (r[3], anchors(&all))],
|
||||
vec![(r[4], anchors(&[])), (r[4], anchors(&[(0, 2)]))],
|
||||
vec![(r[1], anchors(&all)), (r[3], anchors(&all)), (r[1], anchors(&[(0, 0)])), (r[3], anchors(&[(0, 2)]))],
|
||||
vec![(r[8], anchors(&[(0, 0)])), (r[0], anchors(&all)), (r[8], anchors(&all)), (r[0], anchors(&[(0, 1)]))],
|
||||
];
|
||||
let pool: Vec<NodeId> = r.iter().copied().chain([group]).collect();
|
||||
let mut x: u64 = 0x9e37_79b9_7f4a_7c15;
|
||||
let mut next = move || {
|
||||
x ^= x << 13;
|
||||
x ^= x >> 7;
|
||||
x ^= x << 17;
|
||||
x
|
||||
};
|
||||
for len in [3, 9, 25, 80, 200] {
|
||||
let items = (0..len)
|
||||
.map(|_| {
|
||||
let id = pool[(next() % pool.len() as u64) as usize];
|
||||
// Bits 0 to 4 of a draw pick anchors 0 to 3 and one past the end.
|
||||
let bits = next();
|
||||
let refs = (0..5).filter(|i| (bits >> i) & 1 == 1).map(|i| (0, i)).collect();
|
||||
(id, refs)
|
||||
})
|
||||
.collect();
|
||||
streams.push(items);
|
||||
}
|
||||
streams
|
||||
}
|
||||
|
||||
/// Starting selections: the seeded one, none, every rectangle whole, and every rectangle with
|
||||
/// one anchor.
|
||||
fn starts(r: &[NodeId], group: NodeId) -> Vec<Selection> {
|
||||
let mut whole = Selection::default();
|
||||
whole.set(r.iter().copied().chain([group]));
|
||||
let mut partial = whole.clone();
|
||||
for id in r {
|
||||
partial.anchors.insert(*id, anchors(&[(0, 1)]));
|
||||
}
|
||||
vec![seeded(r, group), Selection::default(), whole, partial]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn anchor_items_do_what_the_item_by_item_loop_does() {
|
||||
let (d, r, group) = doc(12);
|
||||
for start in starts(&r, group) {
|
||||
for items in item_streams(&r, group) {
|
||||
for mode in MODES {
|
||||
let mut expected = start.clone();
|
||||
item_by_item(&d, &mut expected, items.clone(), mode);
|
||||
let mut got = start.clone();
|
||||
select_anchor_items(&d, &mut got, items.clone(), mode);
|
||||
assert_eq!(got, expected, "mode {mode}, items {items:?}, from {start:?}");
|
||||
assert_eq!(got.new_art, expected.new_art);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_path_deselected_and_selected_again_goes_last_without_its_key() {
|
||||
let (d, r, group) = doc(12);
|
||||
let all = anchors(&[(0, 0), (0, 1), (0, 2), (0, 3)]);
|
||||
let mut s = seeded(&r, group);
|
||||
// Toggling the selected anchors of 1 and 3 deselects them; toggling again selects them again.
|
||||
let items = vec![(r[1], anchors(&[(0, 0), (0, 1)])), (r[3], anchors(&[(0, 2)])), (r[1], anchors(&[(0, 0)])), (r[3], all)];
|
||||
select_anchor_items(&d, &mut s, items, "toggle");
|
||||
assert_eq!(s.objects, [r[0], r[2], group, r[2], r[4], r[1], r[3]]);
|
||||
assert_eq!(s.anchors.get(&r[1]), Some(&anchors(&[(0, 0)])));
|
||||
assert_eq!(s.anchors.get(&r[3]), None);
|
||||
assert_eq!((s.key, s.key_anchor), (None, None));
|
||||
}
|
||||
|
||||
/// Every rectangle with one anchor, as a Direct Selection marquee sends them.
|
||||
fn marquee(r: &[NodeId]) -> Items {
|
||||
r.iter().map(|id| (*id, anchors(&[(0, 0)]))).collect()
|
||||
}
|
||||
|
||||
/// Every rectangle with all four anchors, which deselects each in subtract mode.
|
||||
fn every_anchor(r: &[NodeId]) -> Items {
|
||||
r.iter().map(|id| (*id, anchors(&[(0, 0), (0, 1), (0, 2), (0, 3)]))).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn anchor_items_walk_the_selected_objects_at_most_twice() {
|
||||
let (d, r, group) = doc(2000);
|
||||
let mut all = Selection::default();
|
||||
all.set(r.iter().copied().chain([group]));
|
||||
for (start, items, mode) in [
|
||||
(Selection::default(), marquee(&r), "set"),
|
||||
(all.clone(), marquee(&r), "toggle"),
|
||||
(all.clone(), every_anchor(&r), "subtract"),
|
||||
(all.clone(), every_anchor(&r).into_iter().chain(marquee(&r)).collect(), "toggle"),
|
||||
] {
|
||||
let mut s = start;
|
||||
OBJECTS_WALKS.set(0);
|
||||
select_anchor_items(&d, &mut s, items, mode);
|
||||
let walks = OBJECTS_WALKS.get();
|
||||
assert!(walks <= 2, "{mode}: {walks} walks over the selected objects");
|
||||
}
|
||||
}
|
||||
|
||||
/// The CPU time this thread has used, from Linux's scheduler statistics; `None` elsewhere.
|
||||
fn thread_cpu() -> Option<Duration> {
|
||||
let stat = std::fs::read_to_string("/proc/thread-self/schedstat").ok()?;
|
||||
stat.split_whitespace().next()?.parse().ok().map(Duration::from_nanos)
|
||||
}
|
||||
|
||||
/// The time `f` takes: this thread's CPU time where Linux reports it, otherwise the wall clock.
|
||||
fn time(f: impl FnOnce()) -> Duration {
|
||||
match thread_cpu() {
|
||||
Some(before) => {
|
||||
f();
|
||||
thread_cpu().map_or(Duration::ZERO, |after| after.saturating_sub(before))
|
||||
}
|
||||
None => {
|
||||
let start = Instant::now();
|
||||
f();
|
||||
start.elapsed()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn ms(d: Duration) -> f64 {
|
||||
d.as_secs_f64() * 1000.0
|
||||
}
|
||||
|
||||
/// Timings of the item loop and the item-by-item loop on 2,000, 20,000 and 50,000 rectangles, run
|
||||
/// in turn on clones of the same selection, 7 runs each. Ignored by default; it prints the median,
|
||||
/// fastest and slowest run and sets no bound on them:
|
||||
/// `cargo test --release -p vectorcraft-engine --lib anchor_items_perf -- --ignored --nocapture`.
|
||||
#[test]
|
||||
#[ignore = "a benchmark: run with --ignored --nocapture"]
|
||||
fn anchor_items_perf() {
|
||||
const RUNS: usize = 7;
|
||||
eprintln!("anchor_items_perf: {}", if thread_cpu().is_some() { "thread CPU time" } else { "wall clock" });
|
||||
eprintln!("anchor_items_perf: {:>6} {:<26} {:>28} {:>28}", "paths", "case", "item by item ms (min-max)", "item loop ms (min-max)");
|
||||
for n in [2_000, 20_000, 50_000] {
|
||||
let (d, r, group) = doc(n);
|
||||
let mut all = Selection::default();
|
||||
all.set(r.iter().copied().chain([group]));
|
||||
for (case, start, items, mode) in [
|
||||
("set, marquee", Selection::default(), marquee(&r), "set"),
|
||||
("add, marquee", Selection::default(), marquee(&r), "add"),
|
||||
("toggle, Select All", all.clone(), marquee(&r), "toggle"),
|
||||
("subtract every anchor", all.clone(), every_anchor(&r), "subtract"),
|
||||
] {
|
||||
let (mut old, mut new) = (Vec::new(), Vec::new());
|
||||
for run in 0..RUNS {
|
||||
let (mut a, mut b) = (start.clone(), start.clone());
|
||||
let (ia, ib) = (items.clone(), items.clone());
|
||||
// The two loops take turns going first.
|
||||
if run % 2 == 0 {
|
||||
old.push(time(|| item_by_item(&d, &mut a, ia, mode)));
|
||||
new.push(time(|| select_anchor_items(&d, &mut b, ib, mode)));
|
||||
} else {
|
||||
new.push(time(|| select_anchor_items(&d, &mut b, ib, mode)));
|
||||
old.push(time(|| item_by_item(&d, &mut a, ia, mode)));
|
||||
}
|
||||
assert_eq!(a, b, "{n} paths, {case}");
|
||||
}
|
||||
old.sort();
|
||||
new.sort();
|
||||
eprintln!(
|
||||
"anchor_items_perf: {n:>6} {case:<26} {:>10.3} ({:>7.3}-{:>8.3}) {:>10.3} ({:>7.3}-{:>8.3})",
|
||||
ms(old[RUNS / 2]),
|
||||
ms(old[0]),
|
||||
ms(old[RUNS - 1]),
|
||||
ms(new[RUNS / 2]),
|
||||
ms(new[0]),
|
||||
ms(new[RUNS - 1]),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -53,7 +53,15 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
has_doc,
|
||||
style_delete
|
||||
),
|
||||
cmd!("graphicStyle.duplicate", "Duplicate Graphic Style", ["Window", "Graphic Styles"], None, "{name} → {name}", has_doc, style_duplicate),
|
||||
cmd!(
|
||||
"graphicStyle.duplicate",
|
||||
"Duplicate Graphic Style",
|
||||
["Window", "Graphic Styles"],
|
||||
None,
|
||||
"{name} a copy of the style at the end of the list, named `<name> copy` (`<name> copy 2`… when that is taken); no object is linked to it → {name}",
|
||||
has_doc,
|
||||
style_duplicate
|
||||
),
|
||||
cmd!(
|
||||
query "graphicStyle.list",
|
||||
"List Graphic Styles",
|
||||
@@ -431,7 +439,7 @@ fn style_duplicate(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let pos = style_index(d, &name)?;
|
||||
let nm = unique_name(&format!("{name} copy"), |n| d.graphic_style(n).is_some());
|
||||
let g = GraphicStyle { name: nm.clone(), id: d.next_graphic_style_id(), ..d.graphic_styles[pos].clone() };
|
||||
d.graphic_styles.insert(pos + 1, g);
|
||||
d.graphic_styles.push(g);
|
||||
Ok(nm)
|
||||
})?;
|
||||
Ok(json!({"name": new}))
|
||||
|
||||
@@ -19,7 +19,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"New Swatch",
|
||||
["Window", "Swatches"],
|
||||
None,
|
||||
"{name?, color? | colors?: [colour] (one swatch each, in one undo step; #rrggbbaa and #rgba are refused) | swatch? | gradient? | pattern?: name (default: the current fill), tint?: 0..100 (% of the global or spot `swatch`, or of the one the current fill links to), mode?: \"gray\"|\"rgb\"|\"hsb\"|\"lab\"|\"cmyk\"|\"web\" (convert the colour; lab: CIE L*a*b*, how spot colours are usually defined), global?, spot? (a spot colour, always global), group?: colour group name (solid colours only; default: ungrouped), none?: true (the None paint), paint?: paint.setFill params, keepModel?: bool (as paint.setFill)} save a colour, gradient or pattern as a swatch. A tint of a global or spot colour (below 100%, without mode, global or spot) becomes a tint swatch, \"Name 40%\", linked to its base: it follows edits to the base and applies as that tint of it. A gradient swatch keeps the gradient's aspect (with or without start/end) and holds no link to the swatch its gradient came from, and a pattern swatch holds the pattern untransformed. Names are unique (\"Sky 2\"); a colour's default name is its values (\"C=10 M=20 Y=30 K=0\", \"R=255 G=128 B=0\", \"Gray K=40\", \"L=55 a=60 b=40\") → {name, names: [every new swatch]}",
|
||||
"{name?, color? | colors?: [colour | {swatch, tint?}] (one swatch each, in one undo step; #rrggbbaa and #rgba are refused; `{swatch, tint}` is the paint paint.setFill gives, so a tint of a global or spot color becomes a tint swatch) | swatch? | gradient? | pattern?: name (default: the current fill), tint?: 0..100 (% of the global or spot `swatch`, or of the one the current fill links to), mode?: \"gray\"|\"rgb\"|\"hsb\"|\"lab\"|\"cmyk\"|\"web\" (convert the colour; lab: CIE L*a*b*, how spot colours are usually defined), global?, spot? (a spot colour, always global), group?: colour group name (solid colours only; default: ungrouped), none?: true (the None paint), paint?: paint.setFill params, keepModel?: bool (as paint.setFill)} save a colour, gradient or pattern as a swatch. A tint of a global or spot colour (below 100%, without mode, global or spot) becomes a tint swatch, \"Name 40%\", linked to its base: it follows edits to the base and applies as that tint of it. A gradient swatch keeps the gradient's aspect (with or without start/end) and holds no link to the swatch its gradient came from, and a pattern swatch holds the pattern untransformed. Names are unique (\"Sky 2\"); a colour's default name is its values (\"C=10 M=20 Y=30 K=0\", \"R=255 G=128 B=0\", \"Gray K=40\", \"L=55 a=60 b=40\") → {name, names: [every new swatch]}",
|
||||
has_doc,
|
||||
swatch_new
|
||||
),
|
||||
@@ -37,7 +37,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"New Color Group",
|
||||
["Window", "Swatches"],
|
||||
None,
|
||||
"{name?, swatches?: [names] (solid colours move into the group; gradients, patterns and None stay), colors?: [colour] (added as new swatches; #rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill), fromArtwork?: false (add the unique colours of the selected art: fills, strokes, text, gradient stops and mesh points; a colour linked to a global swatch moves that swatch into the group), toGlobal?: true (with fromArtwork: the new swatches are global and the selected art's matching unlinked colours link to them), includeTints?: false (with fromArtwork: tints of global swatches also get swatches of their own)} → {name, swatches: [names in the group], linked: paints linked}",
|
||||
"{name?, swatches?: [names] (solid colours move into the group; gradients, patterns and None stay), colors?: [colour | {swatch, tint?}] (added as new swatches; #rrggbbaa and #rgba are refused; `{swatch, tint}` below 100% of a global or spot color adds a tint swatch, \"Name 40%\", linked to it, and any other `{swatch}` its color), keepModel?: bool (as paint.setFill), fromArtwork?: false (add the unique colours of the selected art: fills, strokes, text, gradient stops and mesh points; a colour linked to a global swatch moves that swatch into the group), toGlobal?: true (with fromArtwork: the new swatches are global and the selected art's matching unlinked colours link to them), includeTints?: false (with fromArtwork: tints of global swatches also get swatches of their own)} → {name, swatches: [names in the group], linked: paints linked}",
|
||||
has_doc,
|
||||
swatch_new_group
|
||||
),
|
||||
@@ -146,9 +146,11 @@ fn swatch_new(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let stored = |c: Color| if mode.is_some() { c } else { super::paint::new_color(s, p, c) };
|
||||
let cs: Vec<Paint> = cs
|
||||
.iter()
|
||||
.map(|c| color_value(c).map(|c| Paint::solid(stored(c))))
|
||||
.collect::<Option<_>>()
|
||||
.ok_or_else(|| bad(C, "bad colour in `colors`"))?;
|
||||
.map(|c| match swatch_entry(s, c, C)? {
|
||||
Some(paint) => Ok(paint),
|
||||
None => color_value(c).map(|c| Paint::solid(stored(c))).ok_or_else(|| bad(C, "bad colour in `colors`")),
|
||||
})
|
||||
.collect::<Result<_>>()?;
|
||||
if cs.is_empty() {
|
||||
return Err(bad(C, "`colors` is empty"));
|
||||
}
|
||||
@@ -216,6 +218,16 @@ fn swatch_new(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(json!({ "name": names[0], "names": names }))
|
||||
}
|
||||
|
||||
/// A `colors` entry of `swatch.new` or `swatch.newGroup` that names a color swatch,
|
||||
/// `{swatch, tint?}`: the paint `paint.setFill {swatch, tint}` applies (a tint of a global or spot
|
||||
/// color stays linked to it). `None` for an entry without `swatch`.
|
||||
fn swatch_entry(s: &Session, v: &Value, cmd: &str) -> Result<Option<Paint>> {
|
||||
let Some(name) = v.get("swatch") else { return Ok(None) };
|
||||
let name = name.as_str().ok_or_else(|| bad(cmd, format!("`swatch` in `colors` must be a swatch name, not {name}")))?;
|
||||
let tint = super::paint::tint_param(v, cmd)?;
|
||||
super::paint::swatch_solid(&s.doc()?.doc, name, tint).map(Some).map_err(|e| bad(cmd, e))
|
||||
}
|
||||
|
||||
/// A gradient or pattern `paint`, parsed from the paint params `p`, as a new or edited swatch
|
||||
/// stores it.
|
||||
fn stored_paint(paint: Paint, p: &Value) -> Paint {
|
||||
@@ -475,10 +487,20 @@ fn swatch_new_group(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let mut names = str_list(p, "swatches");
|
||||
super::paint::check_keep_model(p, C)?;
|
||||
check_switches(p, &["fromArtwork", "toGlobal", "includeTints"], C)?;
|
||||
let colors: Vec<Color> = p
|
||||
// A `{swatch, tint}` entry below 100% becomes a tint swatch linked to its base; any other
|
||||
// entry becomes a process color swatch.
|
||||
let colors: Vec<Paint> = p
|
||||
.get("colors")
|
||||
.and_then(Value::as_array)
|
||||
.map(|a| a.iter().map(|v| color_value(v).map(|c| super::paint::new_color(s, p, c)).ok_or_else(|| bad(C, format!("bad color {v}")))).collect())
|
||||
.map(|a| {
|
||||
a.iter()
|
||||
.map(|v| match swatch_entry(s, v, C)? {
|
||||
Some(paint @ Paint::Solid { swatch: Some(_), tint, .. }) if tint < 1.0 => Ok(paint),
|
||||
Some(paint) => paint.color().map(Paint::solid).ok_or_else(|| bad(C, format!("bad color {v}"))),
|
||||
None => color_value(v).map(|c| Paint::solid(super::paint::new_color(s, p, c))).ok_or_else(|| bad(C, format!("bad color {v}"))),
|
||||
})
|
||||
.collect::<Result<Vec<_>>>()
|
||||
})
|
||||
.transpose()?
|
||||
.unwrap_or_default();
|
||||
let from_art = bool_or(p, "fromArtwork", false);
|
||||
@@ -486,15 +508,15 @@ fn swatch_new_group(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let tints = bool_or(p, "includeTints", false);
|
||||
let requested = name_param(p, "name");
|
||||
let (name, members, linked) = s.edit("New Color Group", |d, sel| {
|
||||
// New swatches: (colour, global).
|
||||
let mut new: Vec<(Color, bool)> = colors.iter().map(|c| (*c, false)).collect();
|
||||
// New swatches: (paint, global).
|
||||
let mut new: Vec<(Paint, bool)> = colors.iter().map(|c| (c.clone(), false)).collect();
|
||||
if from_art {
|
||||
if sel.objects.is_empty() {
|
||||
return Err(bad(C, "select artwork to make a group of its colours"));
|
||||
}
|
||||
let mut art = vec![];
|
||||
artwork_colors(d, &sel.objects, tints, &mut names, &mut art);
|
||||
new.extend(art.into_iter().map(|c| (c, to_global)));
|
||||
new.extend(art.into_iter().map(|c| (Paint::solid(c), to_global)));
|
||||
}
|
||||
let name = d.free_swatch_name(requested.as_deref().unwrap_or("Color Group"));
|
||||
// Colour groups hold solid colours only.
|
||||
@@ -505,12 +527,13 @@ fn swatch_new_group(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let mut free = d.free_swatch_names();
|
||||
free.insert(&name);
|
||||
group.swatches.iter().for_each(|sw| free.insert(&sw.name));
|
||||
for (c, global) in new {
|
||||
let nm = free.take(&color_name(c));
|
||||
if global {
|
||||
for (paint, global) in new {
|
||||
// A tint swatch is named "Name 40%", a colour after its values.
|
||||
let nm = free.take_new(&paint);
|
||||
if global && let Some(c) = paint.color() {
|
||||
links.push((c, nm.clone()));
|
||||
}
|
||||
group.swatches.push(Swatch { name: nm, paint: Paint::solid(c), global, spot: false });
|
||||
group.swatches.push(Swatch { name: nm, paint, global, spot: false });
|
||||
}
|
||||
let members: Vec<String> = group.swatches.iter().map(|w| w.name.clone()).collect();
|
||||
d.swatch_groups.push(group);
|
||||
|
||||
@@ -270,7 +270,7 @@ fn range_of(p: &Value, len: usize, cmd: &str) -> Result<(usize, usize)> {
|
||||
Ok((a.min(b), a.max(b)))
|
||||
}
|
||||
|
||||
fn edit_range(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
pub(crate) fn edit_range(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
const C: &str = "text.editRange";
|
||||
let id = object_param(p, "id", C)?.ok_or_else(|| bad(C, "missing `id`"))?;
|
||||
let t = text_ref(s, id)?;
|
||||
|
||||
@@ -10,8 +10,8 @@ use super::object::choice;
|
||||
use super::threads::ThreadIndex;
|
||||
use super::typecmd::{area_text, block_gaps, needed_room, refresh_bounds};
|
||||
use super::{
|
||||
CommandSpec, EngineError, Result, Session, bad, checked_ids_param, cmd, find_command, has_clipboard, has_doc, has_selection, number_or,
|
||||
switch_or, targets, text_param,
|
||||
CommandSpec, EngineError, Result, Session, bad, checked_ids_param, cmd, find_command, has_clipboard, has_doc, has_selection, named_ids,
|
||||
number_or, switch_or, targets, text_param,
|
||||
};
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
@@ -111,7 +111,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Insert Character",
|
||||
["Type"],
|
||||
None,
|
||||
"{char: \"bullet\"|\"copyright\"|\"ellipsis\"|\"paragraph\"|\"registered\"|\"section\"|\"trademark\"|\"emDash\"|\"enDash\"|\"discretionaryHyphen\"|\"nonBreakingHyphen\"|\"doubleLeftQuote\"|\"doubleRightQuote\"|\"singleLeftQuote\"|\"singleRightQuote\"|\"emSpace\"|\"enSpace\"|\"hairSpace\"|\"sixthSpace\"|\"thinSpace\"|\"nonBreakingSpace\"|\"figureSpace\"|\"punctuationSpace\"|\"thirdSpace\"|\"quarterSpace\"|\"tab\"|\"forcedLineBreak\"|\"paragraphReturn\" | text: string | code: Windows Alt+0 code (0–255 in Windows-1252, a Unicode code point above: 176 → °, 151 → —) | unicode: hex code point (\"00B0\" or \"U+00B0\"), ids?|id?: object ids (default: the selection)} append to the selected text objects",
|
||||
"{char: \"bullet\"|\"copyright\"|\"ellipsis\"|\"paragraph\"|\"registered\"|\"section\"|\"trademark\"|\"emDash\"|\"enDash\"|\"discretionaryHyphen\"|\"nonBreakingHyphen\"|\"doubleLeftQuote\"|\"doubleRightQuote\"|\"singleLeftQuote\"|\"singleRightQuote\"|\"emSpace\"|\"enSpace\"|\"hairSpace\"|\"sixthSpace\"|\"thinSpace\"|\"nonBreakingSpace\"|\"figureSpace\"|\"punctuationSpace\"|\"thirdSpace\"|\"quarterSpace\"|\"tab\"|\"forcedLineBreak\"|\"paragraphReturn\" | text: string | code: Windows Alt+0 code (0–255 in Windows-1252, a Unicode code point above: 176 → °, 151 → —) | unicode: hex code point (\"00B0\" or \"U+00B0\"), ids?|id?: object ids (default: the selection)} insert at the Type tool's caret, replacing its selection, while it edits text and no ids are given; otherwise append to the selected text objects. forcedLineBreak is U+2028, a new line in the same paragraph; paragraphReturn is a line feed, which starts a new paragraph",
|
||||
has_selection,
|
||||
insert_char
|
||||
),
|
||||
@@ -786,8 +786,9 @@ fn to_point(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let plain = t.plain_text();
|
||||
let baseline = lay.lines.first().map(|l| l.baseline).unwrap_or(fb.y0 + t.first_style().size * 0.8);
|
||||
// Soft wraps → explicit breaks (replace the space before the wrap when there is one).
|
||||
let mut breaks: Vec<usize> =
|
||||
lay.lines.iter().skip(1).map(|l| l.start).filter(|&b| b > 0 && plain.as_bytes().get(b - 1) != Some(&b'\n')).collect();
|
||||
// A line after a paragraph return or a forced line break (U+2028) already starts there.
|
||||
let hard = |b: usize| plain.get(..b).is_some_and(|s| s.ends_with(['\n', '\u{2028}']));
|
||||
let mut breaks: Vec<usize> = lay.lines.iter().skip(1).map(|l| l.start).filter(|&b| b > 0 && !hard(b)).collect();
|
||||
breaks.sort_unstable();
|
||||
breaks.dedup();
|
||||
for b in breaks.into_iter().rev() {
|
||||
@@ -1525,8 +1526,9 @@ pub(crate) fn special_char(name: &str) -> Option<&'static str> {
|
||||
"thirdSpace" => "\u{2004}",
|
||||
"quarterSpace" => "\u{2005}",
|
||||
"tab" => "\t",
|
||||
// Our text model breaks lines at paragraph returns only.
|
||||
"forcedLineBreak" | "paragraphReturn" => "\n",
|
||||
// A line break inside the paragraph, as Shift+Enter types it.
|
||||
"forcedLineBreak" => "\u{2028}",
|
||||
"paragraphReturn" => "\n",
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
@@ -1576,6 +1578,11 @@ fn insert_char(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
(None, None, None, Some(u)) => unicode_char(u).ok_or_else(|| bad(C, format!("`{u}` is no Unicode character")))?.to_string(),
|
||||
(None, None, None, None) => return Err(bad(C, "give `char`, `text`, `code` or `unicode`")),
|
||||
};
|
||||
if named_ids(p)?.is_none()
|
||||
&& let Some(r) = insert_at_type_caret(s, &text)?
|
||||
{
|
||||
return Ok(r);
|
||||
}
|
||||
let ids = texts(s, p, C)?;
|
||||
// When `text` is empty and every object ends with a run of text, the document and its undo
|
||||
// history stay as they are.
|
||||
@@ -1606,6 +1613,44 @@ fn insert_char(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(ids_json(&ids))
|
||||
}
|
||||
|
||||
/// `type.insert` while the Type tool edits text: `text` replaces the tool's selection (inserts at
|
||||
/// its caret) as one undo step, and the caret goes after it. `None` when no text is being edited.
|
||||
fn insert_at_type_caret(s: &mut Session, text: &str) -> Result<Option<Value>> {
|
||||
let tool = s.tool_options();
|
||||
let Some(id) = tool.get("editing").and_then(Value::as_u64).map(NodeId) else { return Ok(None) };
|
||||
let d = &s.doc()?.doc;
|
||||
let Some(NodeKind::Text(t)) = d.node(id).map(|n| &n.kind) else { return Ok(None) };
|
||||
let len = vectorcraft_text::edit::runs_len(&t.runs);
|
||||
let g = |k: &str| tool.get(k).and_then(Value::as_u64).map_or(len, |v| (v as usize).min(len));
|
||||
let (x, y) = (g("start"), g("end"));
|
||||
let (a, b) = (x.min(y), x.max(y));
|
||||
// After Select All in threaded text the whole story is selected: the other frames' text goes
|
||||
// in the same edit, as when typing replaces it.
|
||||
let story: Vec<NodeId> = tool.get("story").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_u64).map(NodeId).collect();
|
||||
let clear: Vec<u64> = if a == 0 && b == len && story.contains(&id) {
|
||||
let has_text = |f: &NodeId| matches!(d.node(*f).map(|n| &n.kind), Some(NodeKind::Text(o)) if !o.runs.iter().all(|r| r.text.is_empty()));
|
||||
story.iter().filter(|f| **f != id && has_text(f)).map(|f| f.0).collect()
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
if text.is_empty() && a == b && clear.is_empty() {
|
||||
return Ok(Some(ids_json(&[id])));
|
||||
}
|
||||
// A typing session ends first: the insertion is a step of its own.
|
||||
if tool.get("typing").and_then(Value::as_bool) == Some(true) {
|
||||
s.set_tool_option("commitTyping", &Value::Bool(true));
|
||||
s.commit_interaction()?;
|
||||
}
|
||||
// The frame's place in the story once the edit has cleared the frames in `clear`.
|
||||
let start: usize =
|
||||
super::panelcmds::story_frames(s, id).iter().take_while(|(f, _)| *f != id).filter(|(f, _)| !clear.contains(&f.0)).map(|(_, n)| n).sum();
|
||||
let r = super::textedit::edit_range(s, &json!({"id": id.0, "start": a, "end": b, "insert": text, "clear": clear}))?;
|
||||
let caret = r.get("caret").and_then(Value::as_u64).map_or(a + text.len(), |c| c as usize);
|
||||
// Threaded text re-flows in the edit: the caret goes to the frame its place moved to.
|
||||
super::panelcmds::select_story_range(s, id, start + caret, start + caret)?;
|
||||
Ok(Some(ids_json(&[id])))
|
||||
}
|
||||
|
||||
// ---------- Find and Replace ----------
|
||||
|
||||
fn is_word(c: char) -> bool {
|
||||
|
||||
@@ -2,6 +2,8 @@
|
||||
//! Magic Wand panel's (session state, kept across tool switches); the tool runs
|
||||
//! `select.magicWand` on click.
|
||||
|
||||
use std::collections::HashSet;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_color::Paint;
|
||||
@@ -188,13 +190,14 @@ impl WandSettings {
|
||||
}
|
||||
}
|
||||
|
||||
/// Paintable leaves (paths, compounds, text, images) that are visible and editable.
|
||||
/// Paintable leaves (paths, compounds, text, images) that are visible and editable, in the order
|
||||
/// of the document walk.
|
||||
fn paintable(doc: &Document) -> Vec<NodeId> {
|
||||
let mut out = vec![];
|
||||
let mut compounds: Vec<NodeId> = vec![];
|
||||
let mut compounds: HashSet<NodeId> = HashSet::new();
|
||||
doc.walk(|n| {
|
||||
if matches!(n.kind, NodeKind::Compound { .. }) {
|
||||
compounds.push(n.id);
|
||||
compounds.insert(n.id);
|
||||
out.push(n.id);
|
||||
} else if !n.is_container() && !n.is_ruler_guide() {
|
||||
out.push(n.id);
|
||||
@@ -210,6 +213,18 @@ fn paintable(doc: &Document) -> Vec<NodeId> {
|
||||
out
|
||||
}
|
||||
|
||||
/// Shift-click: the selected objects in their order, then each hit that isn't selected yet.
|
||||
fn added(selected: &[NodeId], hits: Vec<NodeId>) -> Vec<NodeId> {
|
||||
let seen: HashSet<NodeId> = selected.iter().copied().collect();
|
||||
selected.iter().copied().chain(hits.into_iter().filter(|h| !seen.contains(h))).collect()
|
||||
}
|
||||
|
||||
/// Alt-click: the selected objects that aren't hits, in their order.
|
||||
fn subtracted(selected: &[NodeId], hits: Vec<NodeId>) -> Vec<NodeId> {
|
||||
let hits: HashSet<NodeId> = hits.into_iter().collect();
|
||||
selected.iter().copied().filter(|i| !hits.contains(i)).collect()
|
||||
}
|
||||
|
||||
fn magic_wand(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let id = object_param(p, "id", "select.magicWand")?.ok_or_else(|| bad("select.magicWand", "missing id"))?;
|
||||
let st = s.doc()?;
|
||||
@@ -224,8 +239,8 @@ fn magic_wand(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
.filter(|i| st.doc.node(*i).is_some_and(|n| w.matches(&reference, n, mode)))
|
||||
.collect();
|
||||
let ids: Vec<NodeId> = match str_param(p, "mode").unwrap_or("set") {
|
||||
"add" => st.selection.objects.iter().copied().chain(hits.iter().copied().filter(|h| !st.selection.objects.contains(h))).collect(),
|
||||
"subtract" => st.selection.objects.iter().copied().filter(|i| !hits.contains(i)).collect(),
|
||||
"add" => added(&st.selection.objects, hits),
|
||||
"subtract" => subtracted(&st.selection.objects, hits),
|
||||
"set" => hits,
|
||||
other => return Err(bad("select.magicWand", format!("unknown mode `{other}` (set, add, subtract)"))),
|
||||
};
|
||||
@@ -423,6 +438,252 @@ mod tests {
|
||||
assert_eq!((o["fillTolerance"].as_f64(), o["strokeTolerance"].as_f64()), (Some(32.0), Some(32.0)));
|
||||
}
|
||||
|
||||
/// [`paintable`] with the compound paths kept in a list and searched for each object's parent.
|
||||
fn paintable_by_search(doc: &Document) -> Vec<NodeId> {
|
||||
let mut out = vec![];
|
||||
let mut compounds: Vec<NodeId> = vec![];
|
||||
doc.walk(|n| {
|
||||
if matches!(n.kind, NodeKind::Compound { .. }) {
|
||||
compounds.push(n.id);
|
||||
out.push(n.id);
|
||||
} else if !n.is_container() && !n.is_ruler_guide() {
|
||||
out.push(n.id);
|
||||
}
|
||||
});
|
||||
let editable = doc.editable();
|
||||
out.retain(|id| {
|
||||
!doc.parent_of(*id).is_some_and(|p| compounds.contains(&p))
|
||||
&& editable(*id)
|
||||
&& doc.is_visible(*id)
|
||||
&& doc.node(*id).is_some_and(|n| n.visible)
|
||||
});
|
||||
out
|
||||
}
|
||||
|
||||
/// [`added`] with the selection searched for each hit.
|
||||
fn added_by_search(selected: &[NodeId], hits: &[NodeId]) -> Vec<NodeId> {
|
||||
selected.iter().copied().chain(hits.iter().copied().filter(|h| !selected.contains(h))).collect()
|
||||
}
|
||||
|
||||
/// [`subtracted`] with the hits searched for each selected object.
|
||||
fn subtracted_by_search(selected: &[NodeId], hits: &[NodeId]) -> Vec<NodeId> {
|
||||
selected.iter().copied().filter(|i| !hits.contains(i)).collect()
|
||||
}
|
||||
|
||||
/// A red fill for an even `k` and a blue one for an odd `k`, with a 1 pt black stroke.
|
||||
fn bench_paint(k: usize) -> vectorcraft_doc::Appearance {
|
||||
use vectorcraft_color::Color;
|
||||
let fill = if k.is_multiple_of(2) { Color::rgb(1.0, 0.0, 0.0) } else { Color::rgb(0.0, 0.0, 1.0) };
|
||||
vectorcraft_doc::Appearance::basic(Paint::solid(fill), Paint::solid(Color::BLACK), 1.0)
|
||||
}
|
||||
|
||||
/// Path `k`: a 10 × 10 rectangle painted as [`bench_paint`]. Every 97th path is locked and
|
||||
/// every 89th hidden.
|
||||
fn bench_path(d: &mut Document, k: usize) -> Node {
|
||||
use vectorcraft_geom::{Rect, shapes};
|
||||
let (x, y) = ((k % 200) as f64 * 20.0, (k / 200) as f64 * 20.0);
|
||||
let mut n = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(x, y, x + 10.0, y + 10.0)), bench_paint(k));
|
||||
n.locked = k % 97 == 5;
|
||||
n.visible = k % 89 != 7;
|
||||
n
|
||||
}
|
||||
|
||||
/// A session whose document holds `blocks` × 200 paths on one layer. Each block has a group of
|
||||
/// 10 paths, 25 compound paths of 2 paths each and 140 loose paths, with the group and the
|
||||
/// compound paths among the loose paths. The compound paths alternate red and blue fills, and
|
||||
/// a few are locked or hidden.
|
||||
fn wand_session(blocks: usize) -> Session {
|
||||
use std::sync::Arc;
|
||||
use vectorcraft_geom::FillRule;
|
||||
let mut d = Document::new(4000.0, 4000.0);
|
||||
let mut k = 0;
|
||||
let mut next = |d: &mut Document| {
|
||||
k += 1;
|
||||
bench_path(d, k - 1)
|
||||
};
|
||||
let mut art = vec![];
|
||||
for slot in 0..blocks * 166 {
|
||||
let node = match slot % 166 {
|
||||
0 => {
|
||||
let members = (0..10).map(|_| Arc::new(next(&mut d))).collect();
|
||||
Node::group(d.alloc_id(), members)
|
||||
}
|
||||
c @ 1..=25 => {
|
||||
let members = (0..2).map(|_| Arc::new(next(&mut d))).collect();
|
||||
let mut n = Node::new(d.alloc_id(), NodeKind::Compound { children: members, rule: FillRule::NonZero });
|
||||
n.appearance = bench_paint(c).into();
|
||||
n.locked = slot % 1001 == 3;
|
||||
n.visible = slot % 1003 != 5;
|
||||
n
|
||||
}
|
||||
_ => next(&mut d),
|
||||
};
|
||||
art.push(Arc::new(node));
|
||||
}
|
||||
if let Some(ch) = Arc::make_mut(&mut d.layers[0]).children_mut() {
|
||||
*ch = art;
|
||||
}
|
||||
let mut s = Session::new();
|
||||
s.add_document(d, None);
|
||||
s
|
||||
}
|
||||
|
||||
/// The objects the wand picks when `reference` is clicked, found as before membership sets.
|
||||
fn hits_by_search(s: &Session, reference: NodeId) -> Vec<NodeId> {
|
||||
let st = s.doc().unwrap();
|
||||
let r = st.doc.node(reference).unwrap();
|
||||
let w = s.menu.wand.clone();
|
||||
paintable_by_search(&st.doc).into_iter().filter(|i| w.matches(r, st.doc.node(*i).unwrap(), st.doc.color_mode)).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn membership_sets_give_the_same_objects_in_the_same_order_as_searches() {
|
||||
// 20,000 paths: 5,000 in 2,500 compound paths and 1,000 in 100 groups.
|
||||
let mut s = wand_session(100);
|
||||
let doc = &s.doc().unwrap().doc;
|
||||
let all = paintable(doc);
|
||||
assert!(all == paintable_by_search(doc), "paintable objects differ");
|
||||
// Compound paths stay pickable unless locked or hidden, and their members never are.
|
||||
let pickable: HashSet<NodeId> = all.iter().copied().collect();
|
||||
let (mut compounds, mut skipped) = (0, 0);
|
||||
doc.walk(|n| {
|
||||
if let NodeKind::Compound { children, .. } = &n.kind {
|
||||
compounds += 1;
|
||||
skipped += usize::from(n.locked || !n.visible);
|
||||
assert_eq!(pickable.contains(&n.id), n.visible && !n.locked, "compound path {}", n.id.0);
|
||||
assert!(children.iter().all(|m| !pickable.contains(&m.id)), "a member of compound path {} is pickable", n.id.0);
|
||||
}
|
||||
});
|
||||
assert_eq!(compounds, 2_500);
|
||||
assert!(skipped > 0 && skipped < 100, "{skipped} locked or hidden compound paths");
|
||||
let reference = all[0];
|
||||
let hits = hits_by_search(&s, reference);
|
||||
assert!(hits.len() > 5_000 && hits.len() < all.len() / 2 + 1_000, "{} hits", hits.len());
|
||||
// A selection in another order than the document's: every third object from the end, both
|
||||
// hits and objects that aren't hits.
|
||||
let selected: Vec<NodeId> = all.iter().rev().step_by(3).copied().collect();
|
||||
assert!(selected.iter().any(|i| hits.contains(i)) && selected.iter().any(|i| !hits.contains(i)));
|
||||
assert!(added(&selected, hits.clone()) == added_by_search(&selected, &hits), "Shift-click differs");
|
||||
assert!(subtracted(&selected, hits.clone()) == subtracted_by_search(&selected, &hits), "Alt-click differs");
|
||||
// And through the command, in each mode.
|
||||
let ids: Vec<u64> = selected.iter().map(|i| i.0).collect();
|
||||
for (mode, want) in [("set", hits.clone()), ("add", added_by_search(&selected, &hits)), ("subtract", subtracted_by_search(&selected, &hits))]
|
||||
{
|
||||
s.execute("select.set", &json!({ "ids": ids })).unwrap();
|
||||
assert!(s.doc().unwrap().selection.objects == selected, "select.set kept the order");
|
||||
let r = s.execute("select.magicWand", &json!({"id": reference.0, "mode": mode})).unwrap();
|
||||
assert_eq!(r["count"], json!(want.len()), "{mode}");
|
||||
assert!(s.doc().unwrap().selection.objects == want, "{mode} selects other objects or another order");
|
||||
}
|
||||
}
|
||||
|
||||
/// Time the Magic Wand's paintable walk, Shift-click and Alt-click lists and a whole Shift-click
|
||||
/// on documents of 2,000, 20,000 and 50,000 paths, with membership sets and with the searches
|
||||
/// they replace, alternating 7 runs of each and giving the medians in ms. On Linux the times are
|
||||
/// the thread's CPU time.
|
||||
/// Run with `cargo test --release -p vectorcraft-engine --lib magic_wand_membership_timing -- --ignored --nocapture`.
|
||||
#[test]
|
||||
#[ignore = "manual timing probe; performance depends on machine load"]
|
||||
fn magic_wand_membership_timing() {
|
||||
fn cpu_ns() -> Option<u64> {
|
||||
std::fs::read_to_string("/proc/thread-self/schedstat").ok()?.split_whitespace().next()?.parse().ok()
|
||||
}
|
||||
/// The time of one call of `f`, averaged over `reps` calls.
|
||||
fn time(reps: u32, f: &mut dyn FnMut()) -> f64 {
|
||||
let start = (cpu_ns(), std::time::Instant::now());
|
||||
for _ in 0..reps {
|
||||
f();
|
||||
}
|
||||
let ms = match (start.0, cpu_ns()) {
|
||||
(Some(a), Some(b)) => b.saturating_sub(a) as f64 / 1e6,
|
||||
_ => start.1.elapsed().as_secs_f64() * 1000.0,
|
||||
};
|
||||
ms / f64::from(reps)
|
||||
}
|
||||
fn median(v: &mut [f64]) -> f64 {
|
||||
v.sort_by(f64::total_cmp);
|
||||
v[v.len() / 2]
|
||||
}
|
||||
/// Alternate `old` and `new` 7 times each and print their medians and every run. Each run
|
||||
/// takes the mean of enough calls for about 100 ms.
|
||||
fn compare(paths: usize, what: &str, old: &mut dyn FnMut(), new: &mut dyn FnMut()) {
|
||||
let reps = (100.0 / time(1, old).max(0.1)).clamp(1.0, 200.0) as u32;
|
||||
let (mut o, mut n) = (vec![], vec![]);
|
||||
for _ in 0..7 {
|
||||
o.push(time(reps, old));
|
||||
n.push(time(reps, new));
|
||||
}
|
||||
let runs = format!("calls per run {reps}: {o:.3?} / {n:.3?}");
|
||||
println!("| {paths} | {what} | {:.3} | {:.3} | {runs}", median(&mut o), median(&mut n));
|
||||
}
|
||||
println!("clock: {}", if cpu_ns().is_some() { "thread CPU time" } else { "wall clock" });
|
||||
println!("| paths | step | searches (ms) | sets (ms) | runs");
|
||||
for blocks in [10, 100, 250] {
|
||||
let mut s = wand_session(blocks);
|
||||
let paths = blocks * 200;
|
||||
let st = s.doc().unwrap();
|
||||
let all = paintable(&st.doc);
|
||||
assert!(all == paintable_by_search(&st.doc));
|
||||
let reference = all[0];
|
||||
let hits = hits_by_search(&s, reference);
|
||||
let selected: Vec<NodeId> = all.iter().rev().step_by(2).copied().collect();
|
||||
assert!(added(&selected, hits.clone()) == added_by_search(&selected, &hits));
|
||||
assert!(subtracted(&selected, hits.clone()) == subtracted_by_search(&selected, &hits));
|
||||
let doc = &st.doc;
|
||||
compare(
|
||||
paths,
|
||||
"paintable",
|
||||
&mut || {
|
||||
std::hint::black_box(paintable_by_search(doc));
|
||||
},
|
||||
&mut || {
|
||||
std::hint::black_box(paintable(doc));
|
||||
},
|
||||
);
|
||||
compare(
|
||||
paths,
|
||||
"Shift-click list",
|
||||
&mut || {
|
||||
std::hint::black_box(added_by_search(&selected, &hits));
|
||||
},
|
||||
&mut || {
|
||||
std::hint::black_box(added(&selected, hits.clone()));
|
||||
},
|
||||
);
|
||||
compare(
|
||||
paths,
|
||||
"Alt-click list",
|
||||
&mut || {
|
||||
std::hint::black_box(subtracted_by_search(&selected, &hits));
|
||||
},
|
||||
&mut || {
|
||||
std::hint::black_box(subtracted(&selected, hits.clone()));
|
||||
},
|
||||
);
|
||||
// A whole Shift-click after the selection is set: [`magic_wand`], and its steps with
|
||||
// the searches.
|
||||
let ids = json!({ "ids": selected.iter().map(|i| i.0).collect::<Vec<u64>>() });
|
||||
let click = json!({"id": reference.0, "mode": "add"});
|
||||
let s = std::cell::RefCell::new(&mut s);
|
||||
compare(
|
||||
paths,
|
||||
"select.set, then Shift-click",
|
||||
&mut || {
|
||||
let s = &mut **s.borrow_mut();
|
||||
s.execute("select.set", &ids).unwrap();
|
||||
let before = s.doc().unwrap().selection.objects.clone();
|
||||
let picked = added_by_search(&before, &hits_by_search(s, reference));
|
||||
s.select(|_, sel| sel.set(picked)).unwrap();
|
||||
},
|
||||
&mut || {
|
||||
let s = &mut **s.borrow_mut();
|
||||
s.execute("select.set", &ids).unwrap();
|
||||
magic_wand(s, &click).unwrap();
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn isolation_mode_limits_the_wand_to_the_isolated_group() {
|
||||
let mut s = Session::new();
|
||||
|
||||
@@ -45,6 +45,15 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
has_doc,
|
||||
preview
|
||||
),
|
||||
cmd!(
|
||||
query "webExport.optimizeToFileSize",
|
||||
"Optimize to File Size",
|
||||
[],
|
||||
None,
|
||||
"{desiredK: the desired file size in K (1024 bytes; above 0, at most 1048576), startWith?: current (default: the format given, its JPEG quality or GIF/PNG-8 colors lowered; GIF then takes lossy 100)|auto (GIF for art with transparency or at most 256 colors (blended over the matte without transparency), else JPEG; the other one when the first can't reach the size and the art is opaque), use?: allSlices (default: the image, or the image slices' files together)|eachSlice (every image slice's file)|currentSlice (the `slice` given, else the selected image slice, else the first), slice?: n (1-based, from slice.list), preset?, …the settings of document.exportForWeb} the settings whose files fit in the size, searched by encoding at most 32 trial settings (each one encodes every image it measures); slices share one setting, which every scope changes → {targetBytes, achieved (false: no setting tried fits, and settings are the smallest one found), bytes (as use measures them), format, settings, trials, images, warnings}; writes nothing and changes no remembered setting",
|
||||
has_doc,
|
||||
optimize_to_file_size
|
||||
),
|
||||
cmd!(
|
||||
query "webExport.settings",
|
||||
"Save for Web Settings",
|
||||
@@ -1054,6 +1063,297 @@ fn preview(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
// ---------- Optimize to File Size ----------
|
||||
|
||||
/// The most trial settings `webExport.optimizeToFileSize` encodes. Each trial encodes every image
|
||||
/// it measures once.
|
||||
pub const OPTIMIZE_TRIALS: usize = 32;
|
||||
/// The largest desired file size, in K (1 GiB).
|
||||
pub const MAX_DESIRED_K: f64 = 1_048_576.0;
|
||||
|
||||
/// Where Optimize to File Size starts.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum StartWith {
|
||||
/// The current format, with its JPEG quality or palette colors lowered.
|
||||
Current,
|
||||
/// GIF or JPEG, by the image's content.
|
||||
Auto,
|
||||
}
|
||||
|
||||
/// The pixels `px` (`[x0, y0, x1, y1]`) of `r` as an image: borrowed when `px` is the whole render,
|
||||
/// else a copy.
|
||||
fn file_pixels(r: &WebRender, px: [u32; 4]) -> std::borrow::Cow<'_, [u8]> {
|
||||
if px == [0, 0, r.width, r.height] { std::borrow::Cow::Borrowed(r.rgba.as_slice()) } else { std::borrow::Cow::Owned(crop(r, px)) }
|
||||
}
|
||||
|
||||
/// The settings Optimize to File Size found.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SizeFit {
|
||||
pub settings: WebSettings,
|
||||
/// The size the settings give the measured images.
|
||||
pub bytes: usize,
|
||||
/// Whether `bytes` is within the target.
|
||||
pub achieved: bool,
|
||||
/// The trial settings encoded.
|
||||
pub trials: usize,
|
||||
}
|
||||
|
||||
/// The files a search measures and the trials it has left.
|
||||
struct Trials<'a> {
|
||||
doc: &'a Document,
|
||||
r: &'a WebRender,
|
||||
/// The pixels (`[x0, y0, x1, y1]`) of each file in `r`.
|
||||
files: &'a [[u32; 4]],
|
||||
/// Measure the largest file (else the files together).
|
||||
each: bool,
|
||||
left: usize,
|
||||
used: usize,
|
||||
}
|
||||
|
||||
impl Trials<'_> {
|
||||
/// The size `s` gives the files, encoded one at a time; `None` when no trial is left.
|
||||
fn size(&mut self, s: &WebSettings) -> std::result::Result<Option<usize>, String> {
|
||||
if self.left == 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
self.left -= 1;
|
||||
self.used += 1;
|
||||
let mut out = 0usize;
|
||||
for &px in self.files {
|
||||
let n = optimize(self.doc, &file_pixels(self.r, px), px[2] - px[0], px[3] - px[1], s)?.bytes.len();
|
||||
out = if self.each { out.max(n) } else { out.saturating_add(n) };
|
||||
}
|
||||
Ok(Some(out))
|
||||
}
|
||||
}
|
||||
|
||||
/// `(settings, bytes)` of a trial.
|
||||
pub type Trial = (WebSettings, usize);
|
||||
|
||||
/// Keep `(s, n)` in `smallest` when it is the smallest trial so far.
|
||||
fn keep_smallest(smallest: &mut Option<Trial>, s: WebSettings, n: usize) {
|
||||
if smallest.as_ref().is_none_or(|(_, b)| n < *b) {
|
||||
*smallest = Some((s, n));
|
||||
}
|
||||
}
|
||||
|
||||
/// The values [`highest_within`] measures spread over its range before it narrows a step.
|
||||
pub const OPTIMIZE_SAMPLES: u16 = 6;
|
||||
|
||||
/// Measures the size a setting gives; `None` when no trial is left.
|
||||
pub type MeasureSize<'a> = dyn FnMut(&WebSettings) -> std::result::Result<Option<usize>, String> + 'a;
|
||||
|
||||
/// The highest value in `lo..hi` that `set` gives `start` whose size is within `target`, when the
|
||||
/// value `hi` is over it. A lower value can give a larger file, so the search measures up to
|
||||
/// [`OPTIMIZE_SAMPLES`] values spread over the range, from `hi - 1` down, stops at the first that
|
||||
/// fits, and halves the step between it and the measured value above it, keeping the highest value
|
||||
/// measured within `target`. `None` when no value measured fits or no trial is left; the trials over
|
||||
/// the target go to `smallest`.
|
||||
pub fn highest_within(
|
||||
size: &mut MeasureSize,
|
||||
start: &WebSettings,
|
||||
(lo, hi): (u16, u16),
|
||||
set: fn(&mut WebSettings, u16),
|
||||
target: usize,
|
||||
smallest: &mut Option<Trial>,
|
||||
) -> std::result::Result<Option<Trial>, String> {
|
||||
let with = |v: u16| {
|
||||
let mut s = start.clone();
|
||||
set(&mut s, v);
|
||||
s
|
||||
};
|
||||
if lo >= hi {
|
||||
return Ok(None);
|
||||
}
|
||||
let span = u32::from(hi - lo);
|
||||
let samples = u32::from(OPTIMIZE_SAMPLES).min(span);
|
||||
let (mut above, mut found) = (hi, None);
|
||||
for i in (0..samples).rev() {
|
||||
let step = if samples == 1 { 0 } else { (span - 1) * i / (samples - 1) };
|
||||
let v = lo.saturating_add(u16::try_from(step).unwrap_or(0));
|
||||
let s = with(v);
|
||||
let Some(n) = size(&s)? else { return Ok(None) };
|
||||
if n <= target {
|
||||
found = Some((v, (s, n)));
|
||||
break;
|
||||
}
|
||||
keep_smallest(smallest, s, n);
|
||||
above = v;
|
||||
}
|
||||
let Some((mut lo, mut best)) = found else { return Ok(None) };
|
||||
let mut hi = above;
|
||||
while hi - lo > 1 {
|
||||
let mid = lo + (hi - lo) / 2;
|
||||
let s = with(mid);
|
||||
let Some(n) = size(&s)? else { break };
|
||||
if n <= target {
|
||||
lo = mid;
|
||||
best = (s, n);
|
||||
} else {
|
||||
keep_smallest(smallest, s, n);
|
||||
hi = mid;
|
||||
}
|
||||
}
|
||||
Ok(Some(best))
|
||||
}
|
||||
|
||||
/// Sets the JPEG quality, for [`highest_within`].
|
||||
pub fn set_quality(s: &mut WebSettings, v: u16) {
|
||||
s.quality = u8::try_from(v).unwrap_or(100);
|
||||
}
|
||||
|
||||
/// Sets the palette colors, for [`highest_within`].
|
||||
pub fn set_colors(s: &mut WebSettings, v: u16) {
|
||||
s.colors = v;
|
||||
}
|
||||
|
||||
/// The best settings of `start`'s format within `target`: `start` when it fits, else the highest
|
||||
/// JPEG quality or the most palette colors [`highest_within`] finds that fit, and for GIF, when none
|
||||
/// is found, lossy 100 with the most colors that fit. When nothing tried fits, the smallest trial, not achieved.
|
||||
/// `None` when no trial is left.
|
||||
fn search_format(t: &mut Trials, start: &WebSettings, target: usize) -> std::result::Result<Option<SizeFit>, String> {
|
||||
let fit = |(settings, bytes): Trial, achieved: bool| SizeFit { settings, bytes, achieved, trials: 0 };
|
||||
let Some(n) = t.size(start)? else { return Ok(None) };
|
||||
if n <= target {
|
||||
return Ok(Some(fit((start.clone(), n), true)));
|
||||
}
|
||||
let mut smallest = Some((start.clone(), n));
|
||||
let found = match start.format {
|
||||
WebFormat::Jpg => highest_within(&mut |s: &WebSettings| t.size(s), start, (1, u16::from(start.quality)), set_quality, target, &mut smallest)?,
|
||||
WebFormat::Gif | WebFormat::Png8 => {
|
||||
match highest_within(&mut |s: &WebSettings| t.size(s), start, (2, start.colors), set_colors, target, &mut smallest)? {
|
||||
None if start.format == WebFormat::Gif && start.lossy < 100 => {
|
||||
let lossy = WebSettings { lossy: 100, ..start.clone() };
|
||||
match t.size(&lossy)? {
|
||||
Some(n) if n <= target => Some((lossy, n)),
|
||||
Some(n) => {
|
||||
keep_smallest(&mut smallest, lossy.clone(), n);
|
||||
highest_within(&mut |s: &WebSettings| t.size(s), &lossy, (2, lossy.colors), set_colors, target, &mut smallest)?
|
||||
}
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
found => found,
|
||||
}
|
||||
}
|
||||
WebFormat::Png24 => None,
|
||||
};
|
||||
Ok(match (found, smallest) {
|
||||
(Some(f), _) => Some(fit(f, true)),
|
||||
(None, Some(s)) => Some(fit(s, false)),
|
||||
(None, None) => None,
|
||||
})
|
||||
}
|
||||
|
||||
/// The format Auto Select GIF/JPEG starts with, and whether the files (`[x0, y0, x1, y1]` of `r`)
|
||||
/// are opaque: GIF for files with transparent pixels (when `transparency` keeps them) or at most
|
||||
/// 256 colors, else JPEG. The colors counted are the ones the files are written with: without
|
||||
/// `transparency`, the pixels blended over `matte`.
|
||||
fn auto_format(r: &WebRender, files: &[[u32; 4]], transparency: bool, matte: [u8; 3]) -> (WebFormat, bool) {
|
||||
let stride = r.width as usize * 4;
|
||||
let row =
|
||||
move |y: u32, x0: u32, x1: u32| r.rgba.get(y as usize * stride + x0 as usize * 4..y as usize * stride + x1 as usize * 4).unwrap_or_default();
|
||||
let pixels = || files.iter().flat_map(move |&[x0, y0, x1, y1]| (y0..y1).flat_map(move |y| row(y, x0, x1).as_chunks::<4>().0.iter()));
|
||||
let opaque = !transparency || pixels().all(|p| p[3] == 255);
|
||||
if !opaque {
|
||||
return (WebFormat::Gif, false);
|
||||
}
|
||||
let mut seen = HashSet::new();
|
||||
// An opaque pixel blends to itself.
|
||||
let few = pixels().all(|p| {
|
||||
seen.insert(flatten(p, matte).next().unwrap_or_default());
|
||||
seen.len() <= 256
|
||||
});
|
||||
(if few { WebFormat::Gif } else { WebFormat::Jpg }, true)
|
||||
}
|
||||
|
||||
/// Optimize to File Size: the settings, from `s`, whose files (the pixels `[x0, y0, x1, y1]` of
|
||||
/// `r`) fit in `target` bytes, measured together, or with `each` the largest one. At most
|
||||
/// [`OPTIMIZE_TRIALS`] trial settings are encoded, and a trial encodes the files one at a time.
|
||||
pub fn optimize_to_size(
|
||||
doc: &Document,
|
||||
r: &WebRender,
|
||||
files: &[[u32; 4]],
|
||||
s: &WebSettings,
|
||||
start: StartWith,
|
||||
each: bool,
|
||||
target: usize,
|
||||
) -> std::result::Result<SizeFit, String> {
|
||||
let mut t = Trials { doc, r, files, each, left: OPTIMIZE_TRIALS, used: 0 };
|
||||
let with = |format: WebFormat| WebSettings { format, ..s.clone() };
|
||||
let found = match start {
|
||||
_ if files.is_empty() => None,
|
||||
StartWith::Current => search_format(&mut t, s, target)?,
|
||||
StartWith::Auto => {
|
||||
let (first, opaque) = auto_format(r, files, s.transparency, s.matte_rgb()?.unwrap_or([255; 3]));
|
||||
let other = if first == WebFormat::Gif { WebFormat::Jpg } else { WebFormat::Gif };
|
||||
match search_format(&mut t, &with(first), target)? {
|
||||
Some(a) if !a.achieved && opaque => match search_format(&mut t, &with(other), target)? {
|
||||
Some(b) if b.achieved || b.bytes < a.bytes => Some(b),
|
||||
_ => Some(a),
|
||||
},
|
||||
a => a,
|
||||
}
|
||||
}
|
||||
};
|
||||
let mut best = found.ok_or("Optimize to File Size: there is no image to measure")?;
|
||||
best.trials = t.used;
|
||||
Ok(best)
|
||||
}
|
||||
|
||||
fn optimize_to_file_size(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
const O: &str = "webExport.optimizeToFileSize";
|
||||
let k = p
|
||||
.get("desiredK")
|
||||
.and_then(Value::as_f64)
|
||||
.filter(|k| k.is_finite() && *k > 0.0 && *k <= MAX_DESIRED_K)
|
||||
.ok_or_else(|| bad(O, "give `desiredK`, the desired file size in K (1024 bytes): a number above 0 and at most 1048576"))?;
|
||||
let target = ((k * 1024.0).floor() as usize).max(1);
|
||||
let start = match p.get("startWith").map(Value::as_str) {
|
||||
None | Some(Some("current")) => StartWith::Current,
|
||||
Some(Some("auto")) => StartWith::Auto,
|
||||
Some(_) => return Err(bad(O, "`startWith` is `current` or `auto`")),
|
||||
};
|
||||
let scope = match p.get("use").map(Value::as_str) {
|
||||
None if p.get("slice").is_some() => "currentSlice",
|
||||
None => "allSlices",
|
||||
Some(Some(u @ ("allSlices" | "eachSlice" | "currentSlice"))) => u,
|
||||
Some(_) => return Err(bad(O, "`use` is `allSlices`, `eachSlice` or `currentSlice`")),
|
||||
};
|
||||
let slice = match p.get("slice").map(|v| v.as_u64().filter(|n| *n >= 1 && scope == "currentSlice")) {
|
||||
None => None,
|
||||
Some(Some(n)) => Some(n),
|
||||
Some(None) => return Err(bad(O, "`slice` is a slice number from `slice.list`, with `use: currentSlice`")),
|
||||
};
|
||||
let settings = s.web_settings(p).map_err(|e| bad(O, e))?;
|
||||
let st = s.doc()?;
|
||||
let doc = &st.doc;
|
||||
let failed = vectorcraft_render::decode_failures();
|
||||
let r = render(doc, &settings).map_err(|e| bad(O, e))?;
|
||||
let warnings = undecoded(failed);
|
||||
let areas = doc.slice_layout();
|
||||
let selected = super::slices::selected_slices(doc, &st.selection);
|
||||
let cells = cells(&areas, &selected, &settings, &r).map_err(|e| bad(O, e))?;
|
||||
let image_cells: Vec<&Cell> =
|
||||
cells.iter().filter(|c| c.area.id.and_then(|id| doc.slice_options(id)).is_none_or(|o| o.kind == SliceKind::Image)).collect();
|
||||
let picked: Vec<&Cell> = match (scope, slice) {
|
||||
("currentSlice", Some(n)) => {
|
||||
let c = image_cells.iter().find(|c| c.area.number as u64 == n);
|
||||
vec![*c.ok_or_else(|| bad(O, format!("no slice {n} in the image (see slice.list)")))?]
|
||||
}
|
||||
("currentSlice", None) => {
|
||||
image_cells.iter().find(|c| c.area.id.is_some_and(|id| selected.contains(&id))).or(image_cells.first()).copied().into_iter().collect()
|
||||
}
|
||||
_ => image_cells,
|
||||
};
|
||||
let files: Vec<[u32; 4]> = if cells.is_empty() { vec![[0, 0, r.width, r.height]] } else { picked.iter().map(|c| c.px).collect() };
|
||||
let fit = optimize_to_size(doc, &r, &files, &settings, start, scope == "eachSlice", target).map_err(|e| bad(O, e))?;
|
||||
Ok(json!({
|
||||
"targetBytes": target, "achieved": fit.achieved, "bytes": fit.bytes, "format": fit.settings.format.id(),
|
||||
"settings": fit.settings.to_json(), "trials": fit.trials, "images": files.len(), "warnings": warnings,
|
||||
}))
|
||||
}
|
||||
|
||||
fn settings(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
const S: &str = "webExport.settings";
|
||||
let base = if bool_or(p, "reset", false) { WebSettings::default() } else { s.last_web_settings() };
|
||||
|
||||
Reference in New Issue
Block a user