From b3c15f6e73bf7fc2111061d2e2787a915cfdbeb0 Mon Sep 17 00:00:00 2001 From: dotCooCoo Date: Sun, 15 Nov 2026 22:51:30 -0800 Subject: [PATCH] Symbols: refuse bad Symbolism Tools Options and find spacing with a k-d tree tool.setOption for a Symbolism tool now refuses a method or Symbol Sprayer value outside its lists, and a usePressure, showBrush, proportional or affectsDensity that is not true or false, and sets none of the values. The Symbolism Tools Options dialog checks the same values before it gives the selected symbol sets a new density. Scrunch: Average measured each instance's nearest neighbor by scanning the grid cell around it, which compared every pair when many instances shared a cell. A k-d tree of the instances under the brush now finds each one's nearest neighbor. --- crates/engine/src/cmd/brushsym/symbolism.rs | 94 +++++++++++++------ crates/engine/src/cmd/brushsym/symbols.rs | 2 +- crates/engine/src/tests/symbolism_options.rs | 20 ++++ crates/engine/src/tooling.rs | 1 + crates/tools/src/symbolism.rs | 24 +++++ .../ui-egui/src/dialogs/symbolism_options.rs | 22 ++++- docs/mcp.md | 4 +- 7 files changed, 135 insertions(+), 32 deletions(-) diff --git a/crates/engine/src/cmd/brushsym/symbolism.rs b/crates/engine/src/cmd/brushsym/symbolism.rs index 8f288819b8..0c925abda1 100644 --- a/crates/engine/src/cmd/brushsym/symbolism.rs +++ b/crates/engine/src/cmd/brushsym/symbolism.rs @@ -163,34 +163,65 @@ pub(super) struct Mean { pub gap: Option, } -/// For each of `looks`, the distance to the nearest of the others (infinite for one alone). Each -/// is first looked for in the cells around it of a grid `cell` points wide: one found within `cell` -/// is the nearest, since every one that near is in those cells. Otherwise all are measured. -fn nearest_gaps(looks: &[&Look], cell: f64) -> Vec { - let cell = cell.max(1e-6); - let mut cells: HashMap<(i64, i64), Vec> = HashMap::new(); - for (i, l) in looks.iter().enumerate() { - cells.entry(key(l.center, cell)).or_default().push(i); +/// The x (`axis` 0) or y (`axis` 1) of `p`. +fn coord(p: Point, axis: usize) -> f64 { + if axis == 0 { p.x } else { p.y } +} + +/// Arrange `order` (indices into `pts`) as a k-d tree: the middle entry of each slice splits the +/// rest by x at even depths and by y at odd ones, the smaller values before it. +fn kd_build(order: &mut [usize], pts: &[Point], axis: usize) { + if order.len() <= 1 { + return; } - let distance = |i: usize, j: usize| if i == j { None } else { Some(looks.get(j)?.center.distance(looks.get(i)?.center)) }; - (0..looks.len()) + let mid = order.len() / 2; + let at = |i: &usize| pts.get(*i).map_or(0.0, |p| coord(*p, axis)); + order.select_nth_unstable_by(mid, |a, b| at(a).total_cmp(&at(b))); + let (left, right) = order.split_at_mut(mid); + kd_build(left, pts, 1 - axis); + kd_build(right.get_mut(1..).unwrap_or_default(), pts, 1 - axis); +} + +/// The distance from `pts[i]` to the nearest of the others in k-d tree `order`, if nearer than +/// `best`. Instances on top of each other end the search: none can be nearer. +fn kd_nearest(order: &[usize], pts: &[Point], axis: usize, i: usize, best: &mut f64) { + let (Some(&j), Some(&p)) = (order.get(order.len() / 2), pts.get(i)) else { return }; + let Some(&q) = pts.get(j) else { return }; + if j != i { + *best = best.min(p.distance(q)); + } + if *best == 0.0 { + return; + } + let (left, right) = order.split_at(order.len() / 2); + let right = right.get(1..).unwrap_or_default(); + let diff = coord(p, axis) - coord(q, axis); + let (near, far) = if diff < 0.0 { (left, right) } else { (right, left) }; + kd_nearest(near, pts, 1 - axis, i, best); + // The other side holds nothing nearer than the split line. + if diff.abs() < *best { + kd_nearest(far, pts, 1 - axis, i, best); + } +} + +/// For each of `looks`, the distance to the nearest of the others (infinite for one alone), found +/// through a k-d tree of their centers. +fn nearest_gaps(looks: &[&Look]) -> Vec { + let pts: Vec = looks.iter().map(|l| l.center).collect(); + let mut order: Vec = (0..pts.len()).collect(); + kd_build(&mut order, &pts, 0); + (0..pts.len()) .map(|i| { let mut best = f64::INFINITY; - for j in around(&cells, looks.get(i).map_or(Point::ZERO, |l| l.center), cell) { - best = distance(i, j).map_or(best, |d| best.min(d)); - // Instances on top of each other: none can be nearer. - if best == 0.0 { - break; - } - } - if best <= cell { best } else { (0..looks.len()).filter_map(|j| distance(i, j)).fold(f64::INFINITY, f64::min) } + kd_nearest(&order, &pts, 0, i, &mut best); + best }) .collect() } /// The [`Mean`] of `looks`, the instances under a brush centered on `at` (None for none), with -/// [`Mean::gap`] when `gap_cell` gives the grid width [`nearest_gaps`] uses. -pub(super) fn mean(looks: &[&Look], at: Point, gap_cell: Option) -> Option { +/// [`Mean::gap`] when `with_gap` is set. +pub(super) fn mean(looks: &[&Look], at: Point, with_gap: bool) -> Option { if looks.is_empty() { return None; } @@ -215,7 +246,7 @@ pub(super) fn mean(looks: &[&Look], at: Point, gap_cell: Option) -> Option< // Rotations that cancel out have no mean direction: the first instance's stands for it. let angle = if sin.hypot(cos) > 1e-9 { sin.atan2(cos) } else { looks[0].angle }; // One instance under the brush has no spacing there. - let gap = gap_cell.filter(|_| looks.len() > 1).map(|cell| nearest_gaps(looks, cell).iter().sum::() / n); + let gap = (with_gap && looks.len() > 1).then(|| nearest_gaps(looks).iter().sum::() / n); Some(Mean { scale: (log_scale / n).exp(), angle, @@ -273,7 +304,7 @@ impl Grid { pub fn mean(&self, at: Point, radius: f64, with_gap: bool) -> Option { let near: Vec<&Look> = around(&self.cells, at, self.cell).filter_map(|i| self.looks.get(i)).filter(|l| l.center.distance(at) <= radius).collect(); - mean(&near, at, with_gap.then_some(radius / 4.0)) + mean(&near, at, with_gap) } } @@ -358,20 +389,27 @@ mod tests { Look { center: Point::new(x, y), scale: 1.0, angle: 0.0, opacity: 1.0, fill: None } } + /// The distance from each instance in `from` to the nearest other one in `refs`, measured + /// against every other instance. + fn brute(refs: &[&Look], from: impl Iterator) -> Vec { + from.map(|i| (0..refs.len()).filter(|j| *j != i).map(|j| refs[i].center.distance(refs[j].center)).fold(f64::INFINITY, f64::min)).collect() + } + /// The gaps are each instance's distance to its nearest neighbor, measured against every other /// instance: close pairs whose members are far apart in the order, instances on top of each - /// other, and instances farther apart than the grid's cells. + /// other, instances far from all others, many instances close together, and many on one line. #[test] fn nearest_gaps_match_measuring_every_pair() { let mut looks: Vec = (0..300).map(|i| at(f64::from(i % 20) * 9.0, f64::from(i / 20) * 7.0)).collect(); // The second member of each pair comes 300 places later. looks.extend((0..300).map(|i| at(f64::from(i % 20) * 9.0 + 0.5, f64::from(i / 20) * 7.0))); looks.extend([at(500.0, 500.0), at(500.0, 500.0), at(900.0, 40.0)]); + // 400 instances within one point of each other, and 200 on one upright line. + looks.extend((0..400).map(|i| at(700.0 + f64::from(i % 20) * 0.05, 700.0 + f64::from(i / 20) * 0.05))); + looks.extend((0..200).map(|i| at(-50.0, f64::from(i) * 1.5))); let refs: Vec<&Look> = looks.iter().collect(); - let brute: Vec = (0..refs.len()) - .map(|i| (0..refs.len()).filter(|j| *j != i).map(|j| refs[i].center.distance(refs[j].center)).fold(f64::INFINITY, f64::min)) - .collect(); - assert_eq!(nearest_gaps(&refs, 10.0), brute); - assert_eq!(nearest_gaps(&refs[..1], 10.0), [f64::INFINITY]); + assert_eq!(nearest_gaps(&refs), brute(&refs, 0..refs.len())); + assert_eq!(nearest_gaps(&refs[..1]), [f64::INFINITY]); + assert_eq!(nearest_gaps(&refs[..0]), Vec::::new()); } } diff --git a/crates/engine/src/cmd/brushsym/symbols.rs b/crates/engine/src/cmd/brushsym/symbols.rs index 4338da1bf5..f832e71e22 100644 --- a/crates/engine/src/cmd/brushsym/symbols.rs +++ b/crates/engine/src/cmd/brushsym/symbols.rs @@ -1129,7 +1129,7 @@ pub(super) fn symbol_adjust(s: &mut Session, p: &Value) -> Result { .then(|| { let under = |n: &&Node| instance_center(n).is_some_and(|c| c.distance(*q) <= radius); let looks: Vec<_> = candidates.iter().filter_map(|id| d.node(*id).filter(under).and_then(|n| look(d, n))).collect(); - mean(&looks.iter().collect::>(), *q, None) + mean(&looks.iter().collect::>(), *q, false) }) .flatten(); for id in &candidates { diff --git a/crates/engine/src/tests/symbolism_options.rs b/crates/engine/src/tests/symbolism_options.rs index 65ce6f8242..bb52cf67c4 100644 --- a/crates/engine/src/tests/symbolism_options.rs +++ b/crates/engine/src/tests/symbolism_options.rs @@ -119,6 +119,26 @@ fn average_brings_the_instances_under_the_brush_toward_their_mean() { assert!(pa > oa && pb < 1.0 && (pa - pb).abs() < (1.0 - oa) / 2.0, "{pa} {pb} from {oa}"); } +/// `tool.setOption` refuses a Method, a Symbol Sprayer option or a checkbox value the Symbolism Tools +/// Options do not have, and sets none of the values given with it. +#[test] +fn bad_symbolism_tool_options_are_refused() { + let mut s = session(); + let before = s.tool_options_of("symbolSizer"); + for (values, want) in [ + (json!({"proportional": false, "method": "smooth"}), "`method` must be one of userDefined, average, random"), + (json!({"sprayScrunch": "random"}), "`sprayScrunch` must be one of average, userDefined"), + (json!({"method": "average", "usePressure": 1}), "`usePressure` must be true or false"), + (json!({"affectsDensity": "yes"}), "`affectsDensity` must be true or false"), + ] { + let r = s.set_tool_option_cmd(&json!({"tool": "symbolSizer", "values": values})); + assert_eq!(r, Err(want.to_string()), "{values}"); + assert_eq!(s.tool_options_of("symbolSizer"), before, "{values}"); + } + s.set_tool_option_cmd(&json!({"tool": "symbolSizer", "key": "method", "value": "random"})).unwrap(); + assert_eq!(s.tool_options_of("symbolSizer")["method"], json!("random")); +} + /// Average opacities below the Symbol Screener's least opacity (5%) stay below it: with the Screener /// the instances meet at their mean, and a sprayed instance takes the mean of those under the brush. #[test] diff --git a/crates/engine/src/tooling.rs b/crates/engine/src/tooling.rs index 9250cf8030..2325c1187d 100644 --- a/crates/engine/src/tooling.rs +++ b/crates/engine/src/tooling.rs @@ -1347,6 +1347,7 @@ impl Session { } // Every value is checked before any is set, so an invalid one changes nothing. vectorcraft_tools::builder::check_builder_options(tool.unwrap_or(self.tool.id()), &values)?; + vectorcraft_tools::symbolism::check_options(tool.unwrap_or(self.tool.id()), &values)?; if tool.unwrap_or(self.tool.id()) == vectorcraft_tools::cropimage::ID { use vectorcraft_tools::cropimage as crop; // The most the selected image can be cropped to, when one is selected. diff --git a/crates/tools/src/symbolism.rs b/crates/tools/src/symbolism.rs index 38471ccae1..ce2396c45c 100644 --- a/crates/tools/src/symbolism.rs +++ b/crates/tools/src/symbolism.rs @@ -72,6 +72,30 @@ pub struct SymbolismTool { pub affects_density: bool, } +/// Checks the Symbolism Tools Options in `values` before `tool.setOption` sets any, when `tool` is +/// a symbolism tool: `method` that is not one of [`METHODS`], a Symbol Sprayer option that is not +/// one of [`SPRAY_MODES`], and `usePressure`, `showBrush`, `proportional` or `affectsDensity` that +/// is not true or false are errors. Ok for every other tool and every other key. Saved settings go +/// to the tool's `set_option` instead, which skips a value it cannot read. +pub fn check_options(tool: &str, values: &serde_json::Map) -> Result<(), String> { + if !tool.starts_with("symbol") || create(tool).is_none() { + return Ok(()); + } + let must_be = |key: &str, names: &[&str]| format!("`{key}` must be one of {}", names.join(", ")); + for (key, v) in values { + let error = match key.as_str() { + "usePressure" | "showBrush" | "proportional" | "affectsDensity" => (!v.is_boolean()).then(|| format!("`{key}` must be true or false")), + "method" => one_of(v, &METHODS).is_none().then(|| must_be(key, &METHODS)), + k if SPRAY_ATTRIBUTES.iter().any(|(a, _)| *a == k) => one_of(v, &SPRAY_MODES).is_none().then(|| must_be(key, &SPRAY_MODES)), + _ => None, + }; + if let Some(e) = error { + return Err(e); + } + } + Ok(()) +} + /// `v` as one of `allowed`, when it is one. fn one_of(v: &Value, allowed: &[&'static str]) -> Option<&'static str> { let s = v.as_str()?; diff --git a/crates/ui-egui/src/dialogs/symbolism_options.rs b/crates/ui-egui/src/dialogs/symbolism_options.rs index d3dbbd8e06..677aa63fec 100644 --- a/crates/ui-egui/src/dialogs/symbolism_options.rs +++ b/crates/ui-egui/src/dialogs/symbolism_options.rs @@ -121,8 +121,10 @@ fn selected_sets(app: &VectorcraftApp) -> Vec { fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> DialogResult { let mut values: Map = NUMBERS.iter().filter(|k| d.fields.contains_key(**k)).map(|k| (k.to_string(), json!(d.f64(k, 0.0)))).collect(); - values.extend(SWITCHES.iter().filter(|k| d.fields.contains_key(**k)).map(|k| (k.to_string(), json!(d.bool(k))))); - values.extend(SPRAY.iter().chain(&["method"]).filter(|k| d.fields.contains_key(**k)).map(|k| (k.to_string(), json!(d.str(k))))); + // The checkboxes and choices as the fields hold them, so a value the tools do not have is refused. + values.extend(SWITCHES.iter().chain(&SPRAY).chain(&["method"]).filter_map(|k| Some((k.to_string(), d.fields.get(*k)?.clone())))); + // An option `tool.setOption` refuses leaves the symbol sets as they are too. + vectorcraft_tools::symbolism::check_options(&d.str("tool"), &values)?; let (from, to) = (d.f64(DENSITY_WAS, 0.0).clamp(1.0, 10.0), d.f64("density", 0.0).clamp(1.0, 10.0)); let sets = selected_sets(app); if d.fields.contains_key(DENSITY_WAS) && from != to && !sets.is_empty() { @@ -265,6 +267,22 @@ mod tests { assert!(width(&app) < was * 0.8, "{} of {was}", width(&app)); assert_eq!(undo(&app), steps + 1); assert_eq!(app.session.tool_options_of("symbolSizer")["density"].as_f64(), Some(9.0)); + // An option the tools do not have: neither the set nor the options change. + let (was, steps) = (width(&app), undo(&app)); + app.run("tool.options", json!({"tool": "symbolSprayer"})).unwrap(); + let d = app.ui.dialog.as_mut().unwrap(); + d.fields.insert("density".into(), json!(3)); + d.fields.insert("method".into(), json!("smooth")); + assert!(super::super::confirm(&mut app).is_err()); + assert_eq!((width(&app), undo(&app)), (was, steps)); + app.run("tool.options", json!({"tool": "symbolSprayer"})).unwrap(); + let d = app.ui.dialog.as_mut().unwrap(); + d.fields.insert("density".into(), json!(3)); + d.fields.insert("usePressure".into(), json!(1)); + assert!(super::super::confirm(&mut app).is_err()); + assert_eq!((width(&app), undo(&app)), (was, steps)); + assert_eq!(app.session.tool_options_of("symbolSizer")["density"].as_f64(), Some(9.0)); + app.ui.dialog = None; // Without a set selected only the option changes. app.run("select.set", json!({"ids": []})).unwrap(); let (was, steps) = (width(&app), undo(&app)); diff --git a/docs/mcp.md b/docs/mcp.md index 209069983b..30d85c2056 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -11296,7 +11296,9 @@ intensity), and the Symbolism tools one brush: `diameter` (80), `intensity` (5), `method` (`userDefined`), `showBrush` (true), `sprayScrunch`, `spraySize`, `spraySpin`, `sprayScreen`, `sprayStain` and `sprayStyle` (each `average`), `proportional` (true) and `affectsDensity` (false); these starting values are VectorCraft's own. With `showBrush` the brush's outline follows the pointer, with a dashed ring inside it at -`intensity`/10 of its radius (no ring at 10, with `usePressure` or for the Symbol Sprayer, which uses neither). Interaction state (pins, a reference point) starts afresh. In the +`intensity`/10 of its radius (no ring at 10, with `usePressure` or for the Symbol Sprayer, which uses neither). For a +Symbolism tool, a `method` or Symbol Sprayer value not in those lists, or a `usePressure`, `showBrush`, `proportional` +or `affectsDensity` that is not true or false, is an error that sets none of the values. Interaction state (pins, a reference point) starts afresh. In the desktop app, while the Artboard tool is in use, a change to its `selected` or `active` makes the artboard it then has active the active artboard (the navigator's and the Artboards panel's).