VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Eyedropper: color samples match the canvas and stay within their work limit
dotCooCoo7211dc789ff4
diff --git a/crates/tools/src/xform/eyedropper.rs b/crates/tools/src/xform/eyedropper.rsindex 46b66599b..f2f214935 100644--- a/crates/tools/src/xform/eyedropper.rs+++ b/crates/tools/src/xform/eyedropper.rs@@ -54,15 +54,25 @@ pub fn paint_color_at(paint: &Paint, bounds: Option<vectorcraft_geom::Rect>, p:}/// How many patterns and symbols deep a sample follows art inside art (tile art painted with a-/// pattern, a symbol whose art holds an instance of another).+/// pattern, a symbol whose art holds an instance of another). Art nested deeper gives no color.const MAX_NESTING: usize = 16;-/// Most tiles of one pattern a sample looks at, front to back, for art that paints the point.+/// How many patterns deep the canvas draws tile art painted with a pattern. A pattern nested+/// deeper, like a pattern the document lacks, draws (and samples) as [`MISSING_PATTERN`].+const PATTERN_DEPTH: usize = 3;++/// The gray the canvas fills a pattern with when it does not draw its tiles.+const MISSING_PATTERN: [u8; 3] = [128, 128, 128];++/// Most tiles of one pattern a sample looks at, front to back, for art that paints the point. When+/// more tiles reach the point, the sample gives no color.const MAX_TILES: usize = 1_000;-/// Most work one sample does, in objects looked at: each hit test after the first in a document-/// counts the objects of the document and of its symbols, each pattern tile or symbol instance-/// sampled counts the objects of its art, and every hundred tile positions checked count one.+/// Most work one sample does, in objects looked at: each hit test after the first in the sampled+/// document, and each one in the art of a tile or instance, counts the objects of the document it+/// tests and of the symbols, each pattern tile or symbol instance+/// sampled counts the objects of its art, and every hundred tile positions checked, or points of a+/// mesh's patches looked at, count one./// Art inside art multiplies them; a sample that would need more gives no color.const MAX_WORK: usize = 1_000_000;@@ -76,6 +86,8 @@ struct Sampler<'a> {work: usize,/// The work ran out: the sample gives no color.exhausted: bool,+ /// How many patterns the art being sampled is inside.+ patterns: usize,}impl Sampler<'_> {@@ -113,7 +125,7 @@ pub(crate) fn sample_color_at(cx: &ToolContext, p: Point) -> Option<Color> {let (doc, opts, raster_sample) = (cx.doc, sample_options(cx), cx.raster_sample);vectorcraft_doc::depth::with_deep_stack(|| {let symbol_nodes = doc.symbols.iter().map(|s| s.art.count()).sum();- let mut s = Sampler { doc, opts, raster_sample, symbol_nodes, work: MAX_WORK, exhausted: false };+ let mut s = Sampler { doc, opts, raster_sample, symbol_nodes, work: MAX_WORK, exhausted: false, patterns: 0 };let mut levels: Vec<Option<Document>> = (0..MAX_NESTING).map(|_| None).collect();let c = color_under(&mut s, doc, &mut levels, p, opts);c.filter(|_| !s.exhausted)@@ -128,10 +140,14 @@ fn color_under(s: &mut Sampler, doc: &Document, levels: &mut [Option<Document>],let mut passed: HashSet<NodeId> = HashSet::new();let mut size = None;loop {- // The first hit test is the one a click makes anyway; each one after it may visit every- // object again.- let cost =- if passed.is_empty() { 1 } else { *size.get_or_insert_with(|| s.symbol_nodes + doc.layers.iter().map(|l| l.count()).sum::<usize>()) };+ // The first hit test in the sampled document is the one a click makes anyway; each one+ // after it, and every one in the art of a tile or instance, may visit every object again+ // and measure the symbols' art.+ let cost = if passed.is_empty() && std::ptr::eq(doc, s.doc) {+ 1+ } else {+ *size.get_or_insert_with(|| s.symbol_nodes + doc.layers.iter().map(|l| l.count()).sum::<usize>())+ };s.spend(cost)?;let h = hit_test_visible_skipping(doc, p, opts, &|id| passed.contains(&id))?;let id = paint_owner(doc, h.leaf);@@ -168,6 +184,8 @@ fn node_color_at(s: &mut Sampler, levels: &mut [Option<Document>], n: &Node, on_match &n.kind {NodeKind::Image(_) => image_color_at(s, n, p),NodeKind::Mesh(m) => {+ // Finding the patch point looks at 17 × 17 points of every patch: a hundred count as one unit.+ s.spend((m.rows as usize).saturating_mul(m.cols as usize).saturating_mul(17 * 17) / 100)?;let (r, c, u, v) = m.locate(p)?;Some(m.color_at(r, c, u, v).0)}@@ -201,7 +219,39 @@ pub(crate) fn has_sampleable_paint(cx: &ToolContext, id: vectorcraft_doc::NodeId/// of its tile art at `p` ([`pattern_color_at`]).fn paint_sample(s: &mut Sampler, levels: &mut [Option<Document>], n: &Node, on_stroke: bool, p: Point) -> Option<Color> {let fill_none = n.proxy_paint(false, None).is_none_or(|(p, ..)| p.is_none());- let (paint, to_doc, bounds) = n.proxy_paint(on_stroke || fill_none, None)?;+ let stroke = on_stroke || fill_none;+ // Type takes its paint from its characters, and a colorized object from its colorize paint.+ let items: Vec<usize> = n.appearance.items.iter().enumerate().filter(|(_, it)| it.is_fill() != stroke).map(|(i, _)| i).collect();+ if items.is_empty() || matches!(n.kind, NodeKind::Text(_)) || (!stroke && n.extras().colorize.is_some()) {+ let (paint, to_doc, bounds) = n.proxy_paint(stroke, None)?;+ return paint_color(s, levels, paint, to_doc, bounds, p);+ }+ // The visible fills (or strokes) from the top: where one leaves a gap, the next shows. Of a+ // path's strokes, only the ones that reach `p` count, when any does (a click within the hit+ // tolerance of a stroke may reach none).+ let mut visible: Vec<usize> = items.into_iter().filter(|&i| n.appearance.items.get(i).is_some_and(|it| it.visible())).collect();+ if stroke && let (NodeKind::Path { rule, .. } | NodeKind::Compound { rule, .. }, Some(bp)) = (&n.kind, n.stroke_path()) {+ let reach =+ |i: &usize| matches!(n.appearance.items.get(*i), Some(vectorcraft_doc::AppearanceItem::Stroke(st)) if st.hits(&bp, *rule, p, 0.0));+ if visible.iter().any(&reach) {+ visible.retain(&reach);+ }+ }+ for &i in visible.iter().rev() {+ let Some((paint, to_doc, bounds)) = n.proxy_paint(stroke, Some(i)) else { continue };+ if let Some(c) = paint_color(s, levels, paint, to_doc, bounds, p) {+ return Some(c);+ }+ }+ None+}++/// The color `paint`, in a space `to_doc` places in the document and with box `bounds` there,+/// shows at `p`. A pattern gives the color of its tile art at `p` ([`pattern_color_at`]).+fn paint_color(s: &mut Sampler, levels: &mut [Option<Document>], paint: &Paint, to_doc: Affine, bounds: Rect, p: Point) -> Option<Color> {+ if paint.is_none() {+ return None;+ }if let Paint::Pattern { pattern, xf } = paint {return pattern_color_at(s, levels, pattern, to_doc * *xf, p);}@@ -210,13 +260,30 @@ fn paint_sample(s: &mut Sampler, levels: &mut [Option<Document>], n: &Node, on_s}/// The color pattern `name`, placed in the document by `xf`, shows at `p`: the color of the-/// front-most tile art there. A point the tiles leave empty has no color.+/// front-most tile art there. A point the tiles leave empty has no color. A pattern the document+/// lacks, or one more than [`PATTERN_DEPTH`] patterns deep, shows [`MISSING_PATTERN`].fn pattern_color_at(s: &mut Sampler, levels: &mut [Option<Document>], name: &str, xf: Affine, p: Point) -> Option<Color> {if xf.determinant().abs() < 1e-12 {return None;}+ let [r, g, b] = MISSING_PATTERN;+ let doc = s.doc;+ let Some(def) = doc.patterns.iter().find(|d| d.name == name) else { return Some(Color::rgb8(r, g, b)) };+ if def.art.is_empty() {+ return None;+ }+ if s.patterns >= PATTERN_DEPTH {+ return Some(Color::rgb8(r, g, b));+ }+ s.patterns += 1;+ let c = tiles_color_at(s, levels, def, xf, p);+ s.patterns -= 1;+ c+}++/// The color the front-most tile art of pattern `def`, placed in the document by `xf`, shows at `p`.+fn tiles_color_at(s: &mut Sampler, levels: &mut [Option<Document>], def: &vectorcraft_doc::PatternDef, xf: Affine, p: Point) -> Option<Color> {let doc = s.doc;- let def = doc.patterns.iter().find(|d| d.name == name)?;// Sampled in pattern space, one tile at a time from the front, among the tiles whose art reaches// the point (or meets it at an edge). The art moves by whole tiles, and the patterns it is// painted with move with it.@@ -235,10 +302,25 @@ fn pattern_color_at(s: &mut Sampler, levels: &mut [Option<Document>], name: &strlet bounds: Vec<Option<Rect>> = def.art.iter().map(|a| a.visual_bounds_with(&symbols)).collect();let reaches = |m: Affine| bounds.iter().any(|b| b.is_none_or(|b| m.transform_rect_bbox(b).inflate(1e-6, 1e-6).contains(q)));let scaling = vectorcraft_doc::Scaling { patterns: true, ..Default::default() };+ // The tiles are listed as the canvas lists the ones it draws: by the art's bounds without its+ // symbols. Listing them looks at every tile position near the point widened by those bounds (at+ // most 250,000, past which it lists none): a hundred positions count as one unit, counted first.+ let listed = def.art_bounds().unwrap_or(def.tile).union(def.tile);+ let (w, h) = (def.width(), def.height());+ let (sx, sy) = def.tile_type.steps(w, h);+ let positions = ((near.width() + listed.width() + 2.0 * w) / sx + 3.0) * ((near.height() + listed.height() + 2.0 * h) / sy + 3.0);+ if positions.is_finite() && positions > 0.0 {+ s.spend(positions.min(250_000.0) as usize / 100)?;+ }let offsets = def.offsets_covering(near);// Each tile position is checked against each piece of art: a hundred checks count as one unit.s.spend(offsets.len().saturating_mul(bounds.len().max(1)) / 100)?;- for m in offsets.into_iter().rev().map(|o| def.instance_xf(o)).filter(|m| reaches(*m)).take(MAX_TILES) {+ for (k, m) in offsets.into_iter().rev().map(|o| def.instance_xf(o)).filter(|m| reaches(*m)).enumerate() {+ // A tile past the limit may paint the point: the sample gives no color.+ if k == MAX_TILES {+ s.exhausted = true;+ return None;+ }s.spend(1 + art_nodes)?;let art = def.art.iter().map(|a| {let mut n = (**a).clone();@@ -256,9 +338,12 @@ fn pattern_color_at(s: &mut Sampler, levels: &mut [Option<Document>], name: &str/// as [`node_color_at`] samples an object, with no tolerance around outlines and strokes: only/// what it paints at `p` counts. The art is hit in the first of `levels`, a scratch document with/// the sampled document's symbols, made on first use and emptied for each new piece of art; art-/// inside it uses the levels after it. With no level left, the art gives no color.+/// inside it uses the levels after it. With no level left, the whole sample gives no color.fn art_color_at(s: &mut Sampler, levels: &mut [Option<Document>], art: impl IntoIterator<Item = Node>, p: Point) -> Option<Color> {- let (slot, deeper) = levels.split_first_mut()?;+ let Some((slot, deeper)) = levels.split_first_mut() else {+ s.exhausted = true;+ return None;+ };let doc = s.doc;let scratch = slot.get_or_insert_with(|| {let mut d = Document::new(1.0, 1.0);@@ -755,6 +840,103 @@ mod tests {assert_eq!(at(&d, 150.0, 155.0), "#00ff00");}+ /// A pattern nested more than three patterns deep, and a pattern the document lacks, sample as+ /// the gray the canvas draws them with.+ #[test]+ fn deep_and_missing_patterns_sample_as_the_canvas_draws_them() {+ use vectorcraft_doc::pattern::pattern_paint;+ use vectorcraft_geom::Rect;+ let (mut d, id) = doc_with_rect();+ // "P0" to "P2": a 10 pt tile filled with the next; "P3" a green tile.+ for i in 0..4 {+ let fill = if i == 3 { Paint::solid(Color::rgb(0.0, 1.0, 0.0)) } else { pattern_paint(&format!("P{}", i + 1)) };+ let mut def = vectorcraft_doc::PatternDef::new(&format!("P{i}"), vec![filled_rect(Rect::new(0.0, 0.0, 10.0, 10.0), fill)]);+ def.tile = Rect::new(0.0, 0.0, 10.0, 10.0);+ d.patterns.push(def);+ }+ let (s, p) = (Selection::default(), paint());+ let mut at = |name: &str| {+ d.node_mut(id).unwrap().appearance.set_fill(pattern_paint(name));+ sample_color_at(&cx(&d, &s, &p), Point::new(150.5, 150.5)).map(|c| c.to_hex())+ };+ assert_eq!(at("P1").as_deref(), Some("#00ff00"), "three patterns deep");+ assert_eq!(at("P0").as_deref(), Some("#808080"), "four patterns deep");+ assert_eq!(at("Nope").as_deref(), Some("#808080"), "missing");+ }++ /// Art nested deeper than a sample follows gives no color, rather than the color of what lies+ /// below it.+ #[test]+ fn art_nested_past_the_limit_gives_no_color() {+ use std::sync::Arc;+ use vectorcraft_doc::{NodeId, Symbol};+ use vectorcraft_geom::{Affine, Rect};+ let (mut d, _) = doc_with_rect();+ // "Deep0" to "Deep19": one instance of the next; "Deep20" a green square over the white+ // rectangle.+ for i in 0..20 {+ let next = Arc::new(Node::new(NodeId(0), NodeKind::SymbolInstance { symbol: format!("Deep{}", i + 1), xf: Affine::IDENTITY }));+ d.symbols.push(Symbol { dynamic: false, name: format!("Deep{i}"), art: next });+ }+ d.symbols.push(Symbol {+ dynamic: false,+ name: "Deep20".into(),+ art: filled_rect(Rect::new(100.0, 100.0, 200.0, 200.0), Paint::solid(Color::rgb(0.0, 1.0, 0.0))),+ });+ let (l, inst) = (d.layers[0].id, d.alloc_id());+ d.insert(Some(l), usize::MAX, Node::new(inst, NodeKind::SymbolInstance { symbol: "Deep0".into(), xf: Affine::IDENTITY })).unwrap();+ let (s, p) = (Selection::default(), paint());+ assert_eq!(sample_color_at(&cx(&d, &s, &p), Point::new(150.5, 150.5)).map(|c| c.to_hex()), None);+ }++ /// A pattern with more tiles over the point than a sample looks at gives no color, rather than+ /// the color of what lies below it.+ #[test]+ fn too_many_tiles_over_the_point_give_no_color() {+ use vectorcraft_doc::pattern::pattern_paint;+ use vectorcraft_geom::{PathData, Rect, SubPath};+ let (mut d, _) = doc_with_rect();+ // An L 0.1 pt thick along the top and left of (0, 0)–(200, 200) on 1 pt tiles: thousands of+ // tiles reach (150.5, 150.5), and none of them paints it.+ let l: Vec<Point> = [(0.0, 0.0), (200.0, 0.0), (200.0, 0.1), (0.1, 0.1), (0.1, 200.0), (0.0, 200.0)].map(|(x, y)| Point::new(x, y)).into();+ let mut el = (*filled_rect(Rect::new(0.0, 0.0, 1.0, 1.0), Paint::solid(Color::BLACK))).clone();+ if let NodeKind::Path { path, .. } = &mut el.kind {+ *path = PathData::single(SubPath::polyline(&l, true));+ }+ let mut def = vectorcraft_doc::PatternDef::new("Ls", vec![std::sync::Arc::new(el)]);+ def.tile = Rect::new(0.0, 0.0, 1.0, 1.0);+ d.patterns.push(def);+ let (l, top) = (d.layers[0].id, d.alloc_id());+ let mut over = (*filled_rect(Rect::new(100.0, 100.0, 200.0, 200.0), pattern_paint("Ls"))).clone();+ over.id = top;+ d.insert(Some(l), usize::MAX, over).unwrap();+ let (s, p) = (Selection::default(), paint());+ assert_eq!(sample_color_at(&cx(&d, &s, &p), Point::new(150.5, 150.5)).map(|c| c.to_hex()), None);+ }++ /// Symbol art in a tile is sampled only in the tiles the canvas draws, which it lists by the+ /// art's bounds without its symbols.+ #[test]+ fn symbol_art_far_outside_its_tile_samples_as_the_canvas_draws_it() {+ use std::sync::Arc;+ use vectorcraft_doc::NodeId;+ use vectorcraft_geom::{Affine, Rect};+ let (mut d, id) = doc_with_rect();+ // A 20 pt tile holding an instance of a 10 pt green square that sits 100 pt right of it.+ // The canvas lists only the tile over a point, whose square lies 100 pt away, so it draws+ // no green at x 165, where the square of the tile at x 60 would lie, or at x 175.+ let green = Paint::solid(Color::rgb(0.0, 1.0, 0.0));+ d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Away".into(), art: filled_rect(Rect::new(100.0, 0.0, 110.0, 10.0), green) });+ let away = Arc::new(Node::new(NodeId(0), NodeKind::SymbolInstance { symbol: "Away".into(), xf: Affine::IDENTITY }));+ let mut def = vectorcraft_doc::PatternDef::new("Away", vec![away]);+ def.tile = Rect::new(0.0, 0.0, 20.0, 10.0);+ d.patterns.push(def);+ d.node_mut(id).unwrap().appearance.set_fill(vectorcraft_doc::pattern::pattern_paint("Away"));+ let (s, p) = (Selection::default(), paint());+ let at = |x: f64| sample_color_at(&cx(&d, &s, &p), Point::new(x, 155.0)).map(|c| c.to_hex());+ assert_eq!((at(165.0), at(175.0)), (None, None));+ }+/// Patterns whose tile art is painted with the next one, on tiles far smaller than their art,/// symbols whose art holds four instances of the next, and symbols nested far deeper than a/// sample follows: each sample stops within its work limit and gives no color, instead of@@ -766,18 +948,27 @@ mod tests {use vectorcraft_doc::{NodeId, Symbol};use vectorcraft_geom::{Affine, Rect};let (mut d, id) = doc_with_rect();- // "Nest0" to "Nest7": 300 pt art on 1 pt tiles, each painted with the next. "Nest8" doesn't- // exist, so no tile gives a color and every one is tried.- for i in 0..8 {- let mut def = vectorcraft_doc::PatternDef::new(- &format!("Nest{i}"),- vec![filled_rect(Rect::new(0.0, 0.0, 300.0, 300.0), pattern_paint(&format!("Nest{}", i + 1)))],- );+ // "Gap": an L 0.1 pt thick along the top and left of (0, 0)–(20, 20) on 1 pt tiles, which+ // reaches every point from hundreds of tiles and paints none at x.5, y.5.+ let l: Vec<Point> = [(0.0, 0.0), (20.0, 0.0), (20.0, 0.1), (0.1, 0.1), (0.1, 20.0), (0.0, 20.0)].map(|(x, y)| Point::new(x, y)).into();+ let mut el = (*filled_rect(Rect::new(0.0, 0.0, 1.0, 1.0), Paint::solid(Color::BLACK))).clone();+ if let NodeKind::Path { path, .. } = &mut el.kind {+ *path = vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&l, true));+ }+ let mut gap = vectorcraft_doc::PatternDef::new("Gap", vec![Arc::new(el)]);+ gap.tile = Rect::new(0.0, 0.0, 1.0, 1.0);+ d.patterns.push(gap);+ // "Nest0" and "Nest1": 300 pt art on 1 pt tiles, painted with the next ("Gap" after+ // "Nest1"), so no tile gives a color and every one is tried.+ for i in 0..2 {+ let next = if i == 1 { "Gap".to_string() } else { format!("Nest{}", i + 1) };+ let mut def =+ vectorcraft_doc::PatternDef::new(&format!("Nest{i}"), vec![filled_rect(Rect::new(0.0, 0.0, 300.0, 300.0), pattern_paint(&next))]);def.tile = Rect::new(0.0, 0.0, 1.0, 1.0);d.patterns.push(def);}d.node_mut(id).unwrap().appearance.set_fill(pattern_paint("Nest0"));- // "Fan0" to "Fan11": four instances of the next symbol; "Fan12" a square filled with "Nest8".+ // "Fan0" to "Fan11": four instances of the next symbol; "Fan12" a square filled with "Gap".let instance = |name: String| Arc::new(Node::new(NodeId(0), NodeKind::SymbolInstance { symbol: name, xf: Affine::IDENTITY }));for i in 0..12 {let art = Node::group(NodeId(0), (0..4).map(|_| instance(format!("Fan{}", i + 1))).collect());@@ -786,7 +977,7 @@ mod tests {d.symbols.push(Symbol {dynamic: false,name: "Fan12".into(),- art: filled_rect(Rect::new(300.0, 300.0, 400.0, 400.0), pattern_paint("Nest8")),+ art: filled_rect(Rect::new(300.0, 300.0, 400.0, 400.0), pattern_paint("Gap")),});// "Deep0" to "Deep99": one instance of the next; "Deep100" a green square.for i in 0..100 {@@ -801,12 +992,92 @@ mod tests {}let (s, p) = (Selection::default(), paint());let start = std::time::Instant::now();- for at in [Point::new(150.0, 150.0), Point::new(350.0, 350.0), Point::new(350.0, 50.0)] {+ for at in [Point::new(150.5, 150.5), Point::new(350.5, 350.5), Point::new(350.5, 50.5)] {assert_eq!(sample_color_at(&cx(&d, &s, &p), at), None, "{at:?}");}assert!(start.elapsed() < std::time::Duration::from_secs(60), "{:?}", start.elapsed());}+ /// Each hit test in a tile's art may measure the art of every symbol, so it counts the symbols'+ /// objects, also when it is the first one in that art and hits nothing.+ #[test]+ fn hit_tests_in_tile_art_count_the_symbols_they_may_measure() {+ use std::sync::Arc;+ use vectorcraft_doc::pattern::pattern_paint;+ use vectorcraft_doc::{NodeId, Symbol};+ use vectorcraft_geom::{Affine, PathData, Rect, SubPath};+ let (mut d, id) = doc_with_rect();+ // Tile art: an L 0.1 pt thick along the top and left of (0, 0)–(200, 200), which no 1 pt+ // tile places over (150.5, 150.5) though the art of a thousand tiles reaches it, and below+ // it an instance of "Dots" (200 squares), which most of those tiles place away from it.+ let l: Vec<Point> = [(0.0, 0.0), (200.0, 0.0), (200.0, 0.1), (0.1, 0.1), (0.1, 200.0), (0.0, 200.0)].map(|(x, y)| Point::new(x, y)).into();+ let el = filled_rect(Rect::new(0.0, 0.0, 1.0, 1.0), Paint::solid(Color::BLACK));+ let mut el = (*el).clone();+ if let NodeKind::Path { path, .. } = &mut el.kind {+ *path = PathData::single(SubPath::polyline(&l, true));+ }+ let green = || Paint::solid(Color::rgb(0.0, 1.0, 0.0));+ let dots = (0..200).map(f64::from).map(|k| filled_rect(Rect::new(k, k, k + 0.1, k + 0.1), green())).collect();+ d.symbols.push(Symbol { dynamic: false, name: "Dots".into(), art: Arc::new(Node::group(NodeId(0), dots)) });+ let far = Affine::translate((0.0, -250.0));+ let inst = Arc::new(Node::new(NodeId(0), NodeKind::SymbolInstance { symbol: "Dots".into(), xf: far }));+ let mut def = vectorcraft_doc::PatternDef::new("Dotted", vec![Arc::new(el), inst]);+ def.tile = Rect::new(0.0, 0.0, 1.0, 1.0);+ d.patterns.push(def);+ d.node_mut(id).unwrap().appearance.set_fill(pattern_paint("Dotted"));+ let (sel, p) = (Selection::default(), paint());+ let cx = cx(&d, &sel, &p);+ let opts = sample_options(&cx);+ let symbol_nodes = d.symbols.iter().map(|s| s.art.count()).sum();+ let mut s = Sampler { doc: &d, opts, raster_sample: cx.raster_sample, symbol_nodes, work: MAX_WORK, exhausted: false, patterns: 0 };+ let mut levels: Vec<Option<Document>> = (0..MAX_NESTING).map(|_| None).collect();+ color_under(&mut s, &d, &mut levels, Point::new(150.5, 150.5), opts);+ // The symbols' objects count for each of at least a hundred tiles, not once for the pattern.+ assert!(MAX_WORK - s.work >= 100 * symbol_nodes, "{} spent, {symbol_nodes} symbol objects", MAX_WORK - s.work);+ }++ /// A gap in an object's top pattern fill shows the object's own fill below it.+ #[test]+ fn a_gap_in_a_top_fill_samples_the_fill_below() {+ use vectorcraft_doc::pattern::pattern_paint;+ use vectorcraft_doc::{AppearanceItem, FillLayer};+ use vectorcraft_geom::Rect;+ // The rectangle (100, 100)–(200, 200) filled with red 10 pt squares 20 pt apart over blue.+ let (mut d, id) = doc_with_rect();+ let mut gappy =+ vectorcraft_doc::PatternDef::new("Gappy", vec![filled_rect(Rect::new(0.0, 0.0, 10.0, 10.0), Paint::solid(Color::rgb(1.0, 0.0, 0.0)))]);+ gappy.tile = Rect::new(0.0, 0.0, 20.0, 10.0);+ d.patterns.push(gappy);+ let ap = &mut d.node_mut(id).unwrap().appearance;+ ap.set_fill(pattern_paint("Gappy"));+ ap.items.insert(0, AppearanceItem::Fill(FillLayer::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0)))));+ let (s, p) = (Selection::default(), paint());+ let at = |x: f64| sample_color_at(&cx(&d, &s, &p), Point::new(x, 155.0)).map(|c| c.to_hex());+ // x 125 is 5 into a tile, on a red square; x 133 is 13 into one, between them.+ assert_eq!((at(125.0), at(133.0)), (Some("#ff0000".to_string()), Some("#0000ff".to_string())));+ // A hidden top fill is not drawn, so the fill below shows on the squares too.+ let mut d = d.clone();+ d.node_mut(id).unwrap().appearance.fill_mut().unwrap().visible = false;+ let at = |x: f64| sample_color_at(&cx(&d, &s, &p), Point::new(x, 155.0)).map(|c| c.to_hex());+ assert_eq!(at(125.0), Some("#0000ff".to_string()));+ }++ /// Of an object's strokes, the topmost one that reaches the point is sampled.+ #[test]+ fn the_topmost_stroke_that_reaches_the_point_is_sampled() {+ use vectorcraft_doc::{AppearanceItem, StrokeLayer};+ // The rectangle (100, 100)–(200, 200) with a 20 pt blue stroke under a 2 pt red one.+ let (mut d, id) = doc_with_rect();+ let ap = &mut d.node_mut(id).unwrap().appearance;+ ap.items.retain(|it| it.is_fill());+ ap.items.push(AppearanceItem::Stroke(StrokeLayer::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), 20.0)));+ ap.items.push(AppearanceItem::Stroke(StrokeLayer::new(Paint::solid(Color::rgb(1.0, 0.0, 0.0)), 2.0)));+ let (s, p) = (Selection::default(), paint());+ let at = |x: f64| sample_color_at(&cx(&d, &s, &p), Point::new(x, 150.0)).map(|c| c.to_hex());+ // x 100 is on both strokes; x 94 is on the blue one only.+ assert_eq!((at(100.0), at(94.0)), (Some("#ff0000".to_string()), Some("#0000ff".to_string())));+ }+/// A gap between a pattern's tile art shows what lies below it, in the document and in the tile/// art of another pattern.#[test]@@ -867,6 +1138,24 @@ mod tests {assert_eq!(sampled_hex(&a), "#404040");}+ /// Finding the point in a mesh counts the points it looks at in every patch: a 20 × 20 mesh+ /// takes more than a thousand units of work.+ #[test]+ fn mesh_samples_count_the_work_of_finding_the_point() {+ use vectorcraft_doc::{Document, GradientMesh};+ let mut d = Document::new(500.0, 500.0);+ let (l, id) = (d.layers[0].id, d.alloc_id());+ let mesh = GradientMesh::from_surface(20, 20, &|u, v| Point::new(100.0 + 100.0 * u, 100.0 + 100.0 * v), &|_, _| Color::rgb(0.0, 1.0, 0.0));+ d.insert(Some(l), 0, Node::new(id, NodeKind::Mesh(mesh))).unwrap();+ let (sel, p) = (Selection::default(), paint());+ let cx = cx(&d, &sel, &p);+ let opts = sample_options(&cx);+ let mut s = Sampler { doc: &d, opts, raster_sample: cx.raster_sample, symbol_nodes: 0, work: 1_000, exhausted: false, patterns: 0 };+ let mut levels: Vec<Option<Document>> = (0..MAX_NESTING).map(|_| None).collect();+ assert_eq!(color_under(&mut s, &d, &mut levels, Point::new(150.0, 150.0), opts).map(|c| c.to_hex()), None);+ assert!(s.exhausted);+ }+#[test]fn gradient_sampled_along_vector() {let g = vectorcraft_color::GradientPaint::new(vectorcraft_color::Gradient::default());