Skip to content

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

Flatten Transparency: group overlapping objects without comparing every open pair

Dylan M. Taylorb032766a6635
diff --git a/crates/engine/src/cmd/flatten/analysis.rs b/crates/engine/src/cmd/flatten/analysis.rs
index 4bdbb8b72..723649940 100644
--- a/crates/engine/src/cmd/flatten/analysis.rs
+++ b/crates/engine/src/cmd/flatten/analysis.rs
@@ -112,8 +112,16 @@ pub(super) fn reach(n: &Node) -> Option<Rect> {
Some(b.inflate(fx + 1.0, fx + 1.0))
}
-/// Indices of `bounds` grouped by overlap (transitively), each group in index order.
-pub(super) fn overlapping(bounds: &[Option<Rect>]) -> Vec<Vec<usize>> {
+/// Indices of `bounds` grouped by overlap (transitively), each group in index order. Boxes that
+/// only touch overlap; a box with a coordinate that isn't finite overlaps none.
+///
+/// A sweep left to right keeps the boxes still open at the current left edge in a tree by their
+/// tops that knows the lowest bottom below each of its branches, so each box meets only the open
+/// boxes it overlaps, not every open one (many objects stacked in a column, sharing their
+/// horizontal extent, would otherwise compare every pair). An open box inside a later box of
+/// its group, ending no further right, is closed early: whatever overlaps it overlaps that box.
+/// Fails only when cancelled ([`vectorcraft_doc::cancel`]).
+pub(super) fn overlapping(bounds: &[Option<Rect>]) -> Result<Vec<Vec<usize>>, vectorcraft_doc::cancel::Cancelled> {
fn find(p: &mut [usize], mut i: usize) -> usize {
while p[i] != i {
p[i] = p[p[i]];
@@ -122,19 +130,75 @@ pub(super) fn overlapping(bounds: &[Option<Rect>]) -> Vec<Vec<usize>> {
i
}
let mut parent: Vec<usize> = (0..bounds.len()).collect();
- let mut order: Vec<(usize, Rect)> = bounds.iter().enumerate().filter_map(|(i, b)| b.map(|b| (i, b))).collect();
- order.sort_by(|a, b| a.1.x0.total_cmp(&b.1.x0));
- // Sweep left to right, comparing each box with those still open at its left edge.
- let mut open: Vec<(usize, Rect)> = vec![];
- for (i, b) in order {
- open.retain(|(_, o)| o.x1 >= b.x0);
- for (j, o) in &open {
- if o.y0 <= b.y1 && b.y0 <= o.y1 {
- let (a, c) = (find(&mut parent, i), find(&mut parent, *j));
- parent[a.max(c)] = a.min(c);
+ let finite = |b: &Rect| [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite()) && b.x0 <= b.x1 && b.y0 <= b.y1;
+ let boxes: Vec<(usize, Rect)> = bounds.iter().enumerate().filter_map(|(i, b)| b.filter(finite).map(|b| (i, b))).collect();
+ let n = boxes.len();
+ // Each box's place in the tree: by top (then index).
+ let mut by_top: Vec<usize> = (0..n).collect();
+ by_top.sort_by(|&a, &b| boxes[a].1.y0.total_cmp(&boxes[b].1.y0).then(a.cmp(&b)));
+ let tops: Vec<f64> = by_top.iter().map(|&k| boxes[k].1.y0).collect();
+ let mut leaf = vec![0usize; n];
+ for (pos, &k) in by_top.iter().enumerate() {
+ leaf[k] = pos;
+ }
+ // The lowest bottom of the open boxes below each node (−∞: none open).
+ let size = n.next_power_of_two().max(1);
+ let mut low = vec![f64::NEG_INFINITY; 2 * size];
+ let set = |low: &mut [f64], pos: usize, v: f64| {
+ let mut i = pos + size;
+ low[i] = v;
+ while i > 1 {
+ i /= 2;
+ low[i] = low[2 * i].max(low[2 * i + 1]);
+ }
+ };
+ let mut by_left: Vec<usize> = (0..n).collect();
+ by_left.sort_by(|&a, &b| boxes[a].1.x0.total_cmp(&boxes[b].1.x0));
+ let mut by_right: Vec<usize> = (0..n).collect();
+ by_right.sort_by(|&a, &b| boxes[a].1.x1.total_cmp(&boxes[b].1.x1));
+ let mut closing = 0;
+ let mut stack: Vec<(usize, usize, usize)> = vec![];
+ let mut met = vec![];
+ let mut work = 0usize;
+ for &k in &by_left {
+ let b = boxes[k].1;
+ // Close the boxes that end left of this one.
+ while let Some(&c) = by_right.get(closing)
+ && boxes[c].1.x1 < b.x0
+ {
+ set(&mut low, leaf[c], f64::NEG_INFINITY);
+ closing += 1;
+ }
+ // The open boxes with their top at most this bottom and their bottom at least this top.
+ let below = tops.partition_point(|t| *t <= b.y1);
+ met.clear();
+ stack.clear();
+ stack.push((1, 0, size));
+ while let Some((node, lo, hi)) = stack.pop() {
+ work += 1;
+ if work % 4096 == 0 {
+ vectorcraft_doc::cancel::check()?;
+ }
+ if lo >= below || low[node] < b.y0 {
+ continue;
+ }
+ if hi - lo == 1 {
+ met.push(by_top[lo]);
+ continue;
+ }
+ let mid = (lo + hi) / 2;
+ stack.push((2 * node + 1, mid, hi));
+ stack.push((2 * node, lo, mid));
+ }
+ for &o in &met {
+ let (a, c) = (find(&mut parent, boxes[k].0), find(&mut parent, boxes[o].0));
+ parent[a.max(c)] = a.min(c);
+ let ob = boxes[o].1;
+ if ob.x1 <= b.x1 && b.y0 <= ob.y0 && ob.y1 <= b.y1 {
+ set(&mut low, leaf[o], f64::NEG_INFINITY);
}
}
- open.push((i, b));
+ set(&mut low, leaf[k], b.y1);
}
let mut groups: Vec<Vec<usize>> = vec![];
let mut slot: Vec<Option<usize>> = vec![None; bounds.len()];
@@ -148,5 +212,83 @@ pub(super) fn overlapping(bounds: &[Option<Rect>]) -> Vec<Vec<usize>> {
}
}
}
- groups
+ Ok(groups)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ /// What [`overlapping`] gives, comparing every pair.
+ fn every_pair(bounds: &[Option<Rect>]) -> Vec<Vec<usize>> {
+ let n = bounds.len();
+ let mut group: Vec<usize> = (0..n).collect();
+ let hit = |a: &Rect, b: &Rect| a.x0 <= b.x1 && b.x0 <= a.x1 && a.y0 <= b.y1 && b.y0 <= a.y1;
+ loop {
+ let mut changed = false;
+ for i in 0..n {
+ for j in 0..n {
+ if let (Some(a), Some(b)) = (bounds[i], bounds[j])
+ && hit(&a, &b)
+ && group[j] < group[i]
+ {
+ group[i] = group[j];
+ changed = true;
+ }
+ }
+ }
+ if !changed {
+ break;
+ }
+ }
+ let mut out: Vec<Vec<usize>> = vec![];
+ let mut seen = std::collections::HashMap::new();
+ for i in 0..n {
+ let g = *seen.entry(group[i]).or_insert_with(|| {
+ out.push(vec![]);
+ out.len() - 1
+ });
+ out[g].push(i);
+ }
+ out
+ }
+
+ /// Boxes of many sizes, nested, touching and apart, group as comparing every pair groups them.
+ #[test]
+ fn groups_match_comparing_every_pair() {
+ let mut seed = 0x2545_f491_4f6c_dd1du64;
+ let mut next = |m: f64| {
+ seed ^= seed << 13;
+ seed ^= seed >> 7;
+ seed ^= seed << 17;
+ (seed % 1000) as f64 / 1000.0 * m
+ };
+ for round in 0..40 {
+ let n = 5 + round * 4;
+ let bounds: Vec<Option<Rect>> = (0..n)
+ .map(|i| {
+ if i % 11 == 3 {
+ return None;
+ }
+ let (x, y) = (next(100.0).round(), next(100.0).round());
+ Some(Rect::new(x, y, x + next(30.0).round(), y + next(30.0).round()))
+ })
+ .collect();
+ assert_eq!(overlapping(&bounds).unwrap(), every_pair(&bounds), "round {round}");
+ }
+ }
+
+ /// A column of many boxes sharing their horizontal extent: each one meets only its
+ /// neighbours, so they group (here, touching in pairs) without comparing every pair.
+ #[test]
+ fn a_tall_column_groups_by_its_neighbours() {
+ let n = 200_000;
+ let bounds: Vec<Option<Rect>> = (0..n).map(|i| Some(Rect::new(0.0, 3.0 * f64::from(i), 100.0, 3.0 * f64::from(i) + if i % 2 == 0 { 3.0 } else { 1.0 }))).collect();
+ let groups = overlapping(&bounds).unwrap();
+ assert_eq!(groups.len(), n as usize / 2);
+ assert!(groups.iter().enumerate().all(|(g, ids)| ids == &[2 * g, 2 * g + 1]));
+ // Boxes that aren't finite overlap nothing.
+ let odd = [Some(Rect::new(0.0, 0.0, 10.0, 10.0)), Some(Rect::new(f64::NAN, 0.0, 10.0, 10.0)), Some(Rect::new(5.0, 5.0, 20.0, 20.0))];
+ assert_eq!(overlapping(&odd).unwrap(), vec![vec![0, 2], vec![1]]);
+ }
}
diff --git a/crates/engine/src/cmd/flatten/apply.rs b/crates/engine/src/cmd/flatten/apply.rs
index d229f1bbb..cccd82ecc 100644
--- a/crates/engine/src/cmd/flatten/apply.rs
+++ b/crates/engine/src/cmd/flatten/apply.rs
@@ -79,7 +79,7 @@ pub(super) fn plan(src: &Document, roots: &[NodeId], o: &FlattenOptions, render:
let mut out = Plan { flat: vec![], kept: vec![], transparent: roots.iter().zip(&see_through).filter(|(_, t)| **t).map(|(id, _)| *id).collect() };
// Baking above stopped early when cancelled; each group is a place to stop (a plan changes nothing).
vectorcraft_doc::cancel::check()?;
- for g in overlapping(&reaches) {
+ for g in overlapping(&reaches)? {
vectorcraft_doc::cancel::check()?;
let ids: Vec<NodeId> = g.iter().map(|&i| roots[i]).collect();
let group = g.iter().any(|&i| see_through[i]).then(|| {