Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

Recolor: recolor.colors and recolor.reduce read the art Select All takes when nothing is selected

dotCooCoo7da8edab793e
diff --git a/crates/engine/src/cmd/recolor.rs b/crates/engine/src/cmd/recolor.rs
index d9a8b487a..ac6553615 100644
--- a/crates/engine/src/cmd/recolor.rs
+++ b/crates/engine/src/cmd/recolor.rs
@@ -1,15 +1,16 @@
-//! Edit → Edit Colors → Recolor Artwork: list the selection's colours, reduce them to rows of
+//! Edit → Edit Colors → Recolor Artwork: list the colors of the selection (or of the art Select All
+//! takes when nothing is selected), reduce them to rows of
//! similar colours, and remap each row to a new colour by a recolour method. Colours are keyed by
//! their identity ([`ColorKey`]: model and exact values), so a CMYK colour stays CMYK and two
//! colours that only look alike stay apart.
-use std::collections::HashMap;
+use std::collections::{BTreeSet, HashMap};
use serde_json::{Value, json};
use vectorcraft_color::recolor::{ColorKey, Method, Preserve, Rng, RowMap, cluster};
use vectorcraft_color::{Color, Paint, Swatch};
-use vectorcraft_doc::swatches::node_colors;
-use vectorcraft_doc::{AppearanceItem, Document, NodeId, NodeKind};
+use vectorcraft_doc::swatches::{node_colors, node_paints};
+use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
use super::colorcmds::{Recolor, Scope};
use super::*;
@@ -21,8 +22,8 @@ pub fn specs() -> Vec<CommandSpec> {
"Artwork Colors",
[],
None,
- "{} → {colors: [{key: colour identity (\"rgb 255 0 0\", \"cmyk 0 100 100 0\", \"gray 40\", \"lab 55 60 -40\"), hex, count, swatch?: the global swatch it is linked to}]} unique colours used by the selection (fills, strokes, gradient stops, text, mesh points and the tiles of pattern fills and strokes), most used first",
- has_selection,
+ "{ids?: object ids (default: the selection, or with nothing selected the objects select.all takes, without the hidden and locked objects inside them)} → {colors: [{key: colour identity (\"rgb 255 0 0\", \"cmyk 0 100 100 0\", \"gray 40\", \"lab 55 60 -40\"), hex, count, swatch?: the global swatch it is linked to}]} unique colours used by the objects (fills, strokes, gradient stops, text, mesh points and the tiles of pattern fills and strokes), most used first",
+ has_doc,
colors
),
cmd!(
@@ -39,8 +40,8 @@ pub fn specs() -> Vec<CommandSpec> {
"Reduce Colors",
[],
None,
- "{colors?: n (rows; default: one per colour, with the tints of a global swatch in its row), method?: as recolor.apply; default scaleTints (picks each row's colour), preserve?: {white?: true, black?: true, grays?: false} (left out of the rows), limitTo?: as recolor.apply (new colours snap to it)} group the selection's colours into rows of similar colours (k-means in Lab, weighted by use) → {map: [{from: [keys, the row's colour first], to: key}], preserved: [keys], method}",
- has_selection,
+ "{colors?: n (rows; default: one per colour, with the tints of a global swatch in its row), method?: as recolor.apply; default scaleTints (picks each row's colour), preserve?: {white?: true, black?: true, grays?: false} (left out of the rows), limitTo?: as recolor.apply (new colours snap to it), ids?: as recolor.colors} group the colors of the objects (default: as recolor.colors) into rows of similar colours (k-means in Lab, weighted by use) → {map: [{from: [keys, the row's colour first], to: key}], preserved: [keys], method}",
+ has_doc,
reduce
),
cmd!(
@@ -62,9 +63,19 @@ struct Used {
swatch: Option<String>,
}
-/// The unique colours of the selection, most used first (ties by key): fills, strokes, gradient
-/// stops, text, mesh points and the tiles of the patterns used as fills or strokes.
-fn used_colors(d: &Document, ids: &[NodeId]) -> Vec<Used> {
+/// The unique colours of the objects `ids` and the objects inside them, most used first (ties by
+/// key): fills, strokes, gradient stops, text, mesh points and the tiles of the patterns used as
+/// fills or strokes. With `only`, an object not in it is left out with everything it holds.
+fn used_colors(d: &Document, ids: &[NodeId], only: Option<&BTreeSet<NodeId>>) -> Vec<Used> {
+ fn read<'a>(n: &'a Node, only: Option<&BTreeSet<NodeId>>, out: &mut Vec<&'a Node>) {
+ if only.is_some_and(|o| !o.contains(&n.id)) {
+ return;
+ }
+ out.push(n);
+ for c in n.children().into_iter().flatten() {
+ read(c, only, out);
+ }
+ }
let mut index: HashMap<ColorKey, usize> = HashMap::new();
let mut used: Vec<(ColorKey, Used)> = vec![];
let mut count = |c: &Color, link: Option<&str>| {
@@ -81,25 +92,22 @@ fn used_colors(d: &Document, ids: &[NodeId]) -> Vec<Used> {
};
// The patterns used as fills or strokes: their tiles count once each.
let mut patterns: Vec<&str> = vec![];
+ let mut nodes = vec![];
for n in ids.iter().filter_map(|id| d.node(*id)) {
- node_colors(n, &mut count);
- n.walk(&mut |m| {
- let runs = match &m.kind {
- NodeKind::Text(t) => t.runs.as_slice(),
- _ => &[],
- };
- let items = m.appearance.items.iter().map(|it| match it {
- AppearanceItem::Fill(l) => &l.paint,
- AppearanceItem::Stroke(l) => &l.paint,
- });
- for p in items.chain(runs.iter().flat_map(|r| [&r.style.fill, &r.style.stroke])) {
- if let Paint::Pattern { pattern, .. } = p
- && !patterns.contains(&pattern.as_str())
- {
- patterns.push(pattern);
- }
+ read(n, only, &mut nodes);
+ }
+ for m in nodes {
+ for p in node_paints(m) {
+ match p {
+ Paint::Solid { color, swatch, .. } => count(color, swatch.as_deref()),
+ Paint::Gradient(g) => g.gradient.stops.iter().for_each(|s| count(&s.color, s.swatch.as_deref())),
+ Paint::Pattern { pattern, .. } if !patterns.contains(&pattern.as_str()) => patterns.push(pattern),
+ _ => {}
}
- });
+ }
+ if let NodeKind::Mesh(mesh) = &m.kind {
+ mesh.points.iter().for_each(|p| count(&p.color, None));
+ }
}
for def in patterns.iter().filter_map(|p| d.pattern(p)) {
def.art.iter().for_each(|n| node_colors(n, &mut count));
@@ -108,9 +116,30 @@ fn used_colors(d: &Document, ids: &[NodeId]) -> Vec<Used> {
used.into_iter().map(|(_, u)| u).collect()
}
-fn colors(s: &mut Session, _: &Value) -> Result<Value> {
+/// The objects whose colors `recolor.colors` and `recolor.reduce` read, for [`used_colors`]: `ids`
+/// (each checked) or else the selection, with everything they hold; with nothing selected, the
+/// objects Select All takes and the objects inside them, leaving out every hidden or locked object
+/// with what it holds and the objects of hidden, locked and template layers (the second value
+/// lists the objects read). Objects listed twice or inside another one listed are dropped, so
+/// their colors count once.
+fn scope_ids(s: &Session, p: &Value, cmd: &str) -> Result<(Vec<NodeId>, Option<BTreeSet<NodeId>>)> {
+ let st = s.doc()?;
+ let ids = match p.get("ids") {
+ Some(_) => checked_ids_param(s, p, "ids", cmd)?,
+ None if st.selection.is_empty() => {
+ let only = super::select::selectable_ids(&st.doc, st.isolation);
+ return Ok((super::select::selectable(&st.doc, st.isolation), Some(only)));
+ }
+ None => st.selection.objects.clone(),
+ };
+ let mut seen = BTreeSet::new();
+ Ok((super::edit::outermost(&st.doc, ids).into_iter().filter(|id| seen.insert(*id)).collect(), None))
+}
+
+fn colors(s: &mut Session, p: &Value) -> Result<Value> {
+ let (ids, only) = scope_ids(s, p, "recolor.colors")?;
let st = s.doc()?;
- let v: Vec<Value> = used_colors(&st.doc, &st.selection.objects)
+ let v: Vec<Value> = used_colors(&st.doc, &ids, only.as_ref())
.iter()
.map(|u| {
let mut v = json!({"key": key_str(&u.color), "hex": u.color.to_hex(), "count": u.count});
@@ -145,8 +174,9 @@ fn reduce(s: &mut Session, p: &Value) -> Result<Value> {
let def = Preserve::default();
let flag = |k: &str, d: bool| p.get("preserve").map_or(d, |v| bool_or(v, k, d));
let preserve = Preserve { white: flag("white", def.white), black: flag("black", def.black), grays: flag("grays", def.grays) };
+ let (ids, only) = scope_ids(s, p, C)?;
let st = s.doc()?;
- let (kept, used): (Vec<Used>, Vec<Used>) = used_colors(&st.doc, &st.selection.objects).into_iter().partition(|u| preserve.keeps(&u.color));
+ let (kept, used): (Vec<Used>, Vec<Used>) = used_colors(&st.doc, &ids, only.as_ref()).into_iter().partition(|u| preserve.keeps(&u.color));
// Units that stay together: the tints of a global swatch, else one colour each.
let mut units: Vec<Vec<&Used>> = vec![];
for u in &used {
diff --git a/crates/engine/src/cmd/select.rs b/crates/engine/src/cmd/select.rs
index efea2f176..e2b7c2a92 100644
--- a/crates/engine/src/cmd/select.rs
+++ b/crates/engine/src/cmd/select.rs
@@ -200,7 +200,7 @@ pub fn specs() -> Vec<CommandSpec> {
/// The objects Select All takes: those of the isolated container, else of every layer (looking
/// through sublayers, which are not objects). In isolation mode there are none while the isolated
/// container, or a group or layer it is in, is hidden, locked or a template layer.
-fn selectable(d: &Document, iso: Option<NodeId>) -> Vec<NodeId> {
+pub(crate) fn selectable(d: &Document, iso: Option<NodeId>) -> Vec<NodeId> {
match iso.and_then(|i| d.node(i)) {
Some(c) if d.ancestry(c.id).is_some_and(|a| a.iter().all(|i| d.node(*i).is_some_and(|n| n.visible && !n.locked && !n.is_template()))) => {
// A single object isolated is all there is to select.
diff --git a/crates/engine/src/tests_recolor.rs b/crates/engine/src/tests_recolor.rs
index bca05af5c..47b8ce45b 100644
--- a/crates/engine/src/tests_recolor.rs
+++ b/crates/engine/src/tests_recolor.rs
@@ -76,6 +76,97 @@ fn five_colours_reduce_to_two() {
assert_eq!(run(&mut s, "recolor.reduce", json!({"colors": (1u64 << 32) + 2}))["map"].as_array().unwrap().len(), 5);
}
+#[test]
+fn colors_with_nothing_selected_come_from_all_the_art() {
+ let mut s = session();
+ let red = rect(&mut s, json!("#ff0000"));
+ let blue = rect(&mut s, json!("#0000ff"));
+ run(&mut s, "select.set", json!({"ids": []}));
+ let hexes = |v: &Value| v["colors"].as_array().unwrap().iter().map(|c| c["hex"].as_str().unwrap().to_string()).collect::<Vec<_>>();
+ let mut all = hexes(&run(&mut s, "recolor.colors", json!({})));
+ all.sort();
+ assert_eq!(all, ["#0000ff", "#ff0000"]);
+ assert!(s.doc().unwrap().selection.objects.is_empty(), "the selection is left as it was");
+ assert_eq!(run(&mut s, "recolor.reduce", json!({}))["map"].as_array().unwrap().len(), 2);
+ // `ids` names the objects; otherwise the selection does.
+ assert_eq!(hexes(&run(&mut s, "recolor.colors", json!({"ids": [blue.0]}))), ["#0000ff"]);
+ // An id listed twice counts once.
+ let once = run(&mut s, "recolor.colors", json!({"ids": [red.0]}))["colors"].clone();
+ assert_eq!(run(&mut s, "recolor.colors", json!({"ids": [red.0, red.0]}))["colors"], once);
+ assert_eq!(run(&mut s, "recolor.reduce", json!({"ids": [red.0]}))["map"][0]["from"], json!(["rgb 255 0 0"]));
+ run(&mut s, "select.set", json!({"ids": [red.0]}));
+ assert_eq!(hexes(&run(&mut s, "recolor.colors", json!({}))), ["#ff0000"]);
+ let e = s.execute("recolor.colors", &json!({"ids": [9999]})).unwrap_err().to_string();
+ assert!(e.contains("no such object id 9999"), "{e}");
+ // Recolor Artwork still recolors only what is selected.
+ run(&mut s, "select.set", json!({"ids": []}));
+ assert!(s.execute("recolor.apply", &json!({"map": {"#ff0000": "#00ff00"}})).is_err());
+ assert_eq!(fill(&s, red).to_hex(), "#ff0000");
+}
+
+#[test]
+fn colors_with_nothing_selected_leave_out_what_select_all_leaves_out() {
+ let mut s = session();
+ rect(&mut s, json!("#ff0000"));
+ let hidden = rect(&mut s, json!("#0000ff"));
+ let locked = rect(&mut s, json!("#00ff00"));
+ run(&mut s, "object.hide", json!({"ids": [hidden.0]}));
+ run(&mut s, "object.lock", json!({"ids": [locked.0]}));
+ // A hidden layer and a locked layer, each holding a rectangle.
+ for (fill, props) in [("#ffff00", json!({"visible": false})), ("#ff00ff", json!({"locked": true}))] {
+ let layer = run(&mut s, "layer.new", json!({}))["id"].as_u64().unwrap();
+ let id = run(&mut s, "shape.rectangle", json!({"x": 300, "y": 10, "width": 15, "height": 15}))["id"].as_u64().unwrap();
+ run(&mut s, "paint.setFill", json!({"ids": [id], "color": fill}));
+ assert_eq!(s.doc().unwrap().doc.layer_containing(NodeId(id)), Some(NodeId(layer)));
+ let mut p = props;
+ p["id"] = json!(layer);
+ run(&mut s, "layer.setProps", p);
+ }
+ let hexes = |v: &Value| v["colors"].as_array().unwrap().iter().map(|c| c["hex"].as_str().unwrap().to_string()).collect::<Vec<_>>();
+ run(&mut s, "select.set", json!({"ids": []}));
+ let none = hexes(&run(&mut s, "recolor.colors", json!({})));
+ assert_eq!(none, ["#ff0000"]);
+ assert_eq!(run(&mut s, "recolor.reduce", json!({}))["map"], json!([{"from": ["rgb 255 0 0"], "to": "rgb 255 0 0"}]));
+ select_all(&mut s);
+ assert_eq!(hexes(&run(&mut s, "recolor.colors", json!({}))), none, "the same colors as after Select All");
+ // `ids` still reads hidden and locked objects.
+ assert_eq!(hexes(&run(&mut s, "recolor.colors", json!({"ids": [hidden.0]}))), ["#0000ff"]);
+}
+
+#[test]
+fn colors_with_nothing_selected_leave_out_hidden_and_locked_objects_in_groups() {
+ let mut s = session();
+ rect(&mut s, json!("#ff0000"));
+ let hidden = rect(&mut s, json!("#0000ff"));
+ let locked = rect(&mut s, json!("#00ff00"));
+ // A group inside the group, holding a hidden rectangle.
+ let inner_hidden = rect(&mut s, json!("#ffff00"));
+ run(&mut s, "select.set", json!({"ids": [inner_hidden.0]}));
+ run(&mut s, "object.group", json!({}));
+ select_all(&mut s);
+ let g = NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap());
+ assert_eq!(s.doc().unwrap().doc.layers[0].children().unwrap().len(), 1, "one group holds the art");
+ run(&mut s, "object.hide", json!({"ids": [hidden.0, inner_hidden.0]}));
+ run(&mut s, "object.lock", json!({"ids": [locked.0]}));
+ let hexes = |v: &Value| {
+ let mut h = v["colors"].as_array().unwrap().iter().map(|c| c["hex"].as_str().unwrap().to_string()).collect::<Vec<_>>();
+ h.sort();
+ h
+ };
+ run(&mut s, "select.set", json!({"ids": []}));
+ assert_eq!(hexes(&run(&mut s, "recolor.colors", json!({}))), ["#ff0000"]);
+ assert_eq!(run(&mut s, "recolor.reduce", json!({}))["map"], json!([{"from": ["rgb 255 0 0"], "to": "rgb 255 0 0"}]));
+ // Isolation mode reads the same objects of the group.
+ run(&mut s, "object.isolate", json!({"id": g.0}));
+ assert_eq!(hexes(&run(&mut s, "recolor.colors", json!({}))), ["#ff0000"]);
+ run(&mut s, "object.exitIsolation", json!({}));
+ // The group named in `ids`, or selected, is read with everything it holds.
+ let all = ["#0000ff", "#00ff00", "#ff0000", "#ffff00"];
+ assert_eq!(hexes(&run(&mut s, "recolor.colors", json!({"ids": [g.0]}))), all);
+ run(&mut s, "select.set", json!({"ids": [g.0]}));
+ assert_eq!(hexes(&run(&mut s, "recolor.colors", json!({}))), all);
+}
+
#[test]
fn preserve_flags_leave_neutrals_out() {
let mut s = session();
diff --git a/docs/mcp.md b/docs/mcp.md
index e96973648..a0ef6e4b1 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -1655,7 +1655,10 @@ patterns out. The Blend commands also grade gradient meshes, which keep their sh
Recolor Artwork keys colours by identity, not hex: `recolor.colors` lists each colour's `key` (`"rgb 255 0 0"`,
`"cmyk 0 100 100 0"`, `"gray 40"`, `"lab 55 60 -40"`; RGB in 0–255 levels, CMYK and Gray in percent), so CMYK,
Lab and RGB colours that look alike stay apart, and every colour parameter also accepts a key.
-`recolor.reduce {colors?, method?, preserve?, limitTo?}` groups the selection's colours into rows of similar colours (k-means in Lab, weighted by use;
+`recolor.colors` and `recolor.reduce` read the objects in `ids`, else the selection. With nothing selected they read
+the objects `select.all` takes, which leaves out hidden and locked art, and the selection is left unchanged; hidden
+and locked objects inside a group are left out too, also in isolation mode.
+`recolor.reduce {colors?, method?, preserve?, limitTo?, ids?}` groups those colours into rows of similar colours (k-means in Lab, weighted by use;
tints of a global swatch share its row; White and Black are preserved by default) and returns a map of rows
`[{from: [keys], to: key}]` to edit and pass to `recolor.apply {map, method?, model?, limitTo?, group?, groupColors?, rename?}`.
For scripts and MCP, `model` selects the replacement color model: `keep` (default) retains each