LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
Brush dabs: build only as far as the caller will look (#1520)
Muhammad Saada3dbe2ab914d
diff --git a/crates/gpu/src/render.rs b/crates/gpu/src/render.rsindex 0c5bd19f0..9fc2b26bc 100644--- a/crates/gpu/src/render.rs+++ b/crates/gpu/src/render.rs@@ -1012,7 +1012,19 @@ fn masks(cx: &mut Cx<'_>, lin: &Buf, prep: &Prep, plan: &Plan<'_>, host: &mut HoSome(3)}MaskShape::Brush { strokes } => {- let dabs: Vec<_> = strokes.iter().map(|st| lightcraft_pipeline::masks::brush_dabs(st, frame, w, h)).collect();+ // The kernel takes at most MAX_DABS across the whole mask, so no more than+ // that (plus one, to tell "at it" from "past it") is ever built: each stroke+ // may otherwise construct two million dabs before the sum below rejects them+ // all (#1520).+ let mut room = MAX_DABS + 1;+ let dabs: Vec<_> = strokes+ .iter()+ .map(|st| {+ let d = lightcraft_pipeline::masks::brush_dabs_within(st, frame, w, h, room);+ room -= d.dabs.len().min(room);+ d+ })+ .collect();// pen pressure varies radius and flow per dab, which the kernel doesn't take: the CPU rasterizes itif dabs.iter().map(|d| d.dabs.len()).sum::<usize>() > MAX_DABS || dabs.iter().any(|d| !d.pressure.is_empty()) {Nonediff --git a/crates/pipeline/src/masks.rs b/crates/pipeline/src/masks.rsindex 36cc29192..a2497a2bd 100644--- a/crates/pipeline/src/masks.rs+++ b/crates/pipeline/src/masks.rs@@ -524,6 +524,19 @@ pub const MAX_STROKE_DABS: usize = 2_000_000;/// The dabs of stroke `s` in a `w × h` output.pub fn brush_dabs(s: &BrushStroke, frame: &Frame, w: usize, h: usize) -> BrushDabs {+ brush_dabs_within(s, frame, w, h, MAX_STROKE_DABS)+}++/// [`brush_dabs`] stopping at `max` dabs instead of [`MAX_STROKE_DABS`].+///+/// For a caller that discards a stroke past a threshold of its own: it builds to that threshold+/// rather than to the stroke budget and throws the difference away. The GPU path rejects a brush+/// mask past 4096 dabs in total and the Auto Mask spot window past 200,000, both far below the+/// two million a single stroke may otherwise construct first (#1520).+///+/// Ask for one more than the threshold to tell "at it" from "past it": a result shorter than+/// `max` is the whole stroke.+pub fn brush_dabs_within(s: &BrushStroke, frame: &Frame, w: usize, h: usize, max: usize) -> BrushDabs {let to_out = frame.norm_to_out(w, h);let ppl = frame.px_per_long(w);let r = (s.size * ppl).max(0.5);@@ -536,10 +549,14 @@ pub fn brush_dabs(s: &BrushStroke, frame: &Frame, w: usize, h: usize) -> BrushDalet with_pressure = !s.pressure.is_empty();let mut prev = None;let mut prev_p = 1.0;+ let mut emitted = 0usize;for (i, p) in s.points.iter().enumerate() {+ if emitted >= max {+ break;+ }let q = to_out.apply(*p);let before = dabs.len();- if push_dabs(&mut dabs, prev, q, r) {+ if push_dabs_within(&mut dabs, &mut emitted, prev, q, r, max) {let pq = s.pressure_at(i);if with_pressure {// the first dab of the stroke has nothing to interpolate from@@ -585,7 +602,16 @@ pub fn push_dabs(dabs: &mut Vec<Point>, prev: Option<Point>, q: Point, r: f64) -/// dabs no longer held in `dabs`. Incremental callers retain `emitted` when clearing their buffer;/// it advances only by the number actually appended. Acceptance and spacing match [`push_dabs`].pub fn push_dabs_counted(dabs: &mut Vec<Point>, emitted: &mut usize, prev: Option<Point>, q: Point, r: f64) -> bool {- let room = MAX_STROKE_DABS.saturating_sub(*emitted);+ push_dabs_within(dabs, emitted, prev, q, r, MAX_STROKE_DABS)+}++/// [`push_dabs_counted`] against a caller's own budget rather than [`MAX_STROKE_DABS`].+///+/// A caller that will not look at more than `max` dabs should build no more than `max`: a length+/// check after the vector exists bounds nothing, it only throws away what was already paid for+/// (#1520).+pub fn push_dabs_within(dabs: &mut Vec<Point>, emitted: &mut usize, prev: Option<Point>, q: Point, r: f64, max: usize) -> bool {+ let room = max.min(MAX_STROKE_DABS).saturating_sub(*emitted);if room == 0 || !(q.x.is_finite() && q.y.is_finite()) {return false;}@@ -856,6 +882,52 @@ mod tests {assert!(e[0].alpha.get(50, 50) < 0.01);}+ /// #1520: a caller that will not look past its own threshold builds to that threshold, not to+ /// the stroke budget. Each segment here is admissible on its own and together they want far+ /// more than any threshold the callers apply, which is the aggregate the issue describes+ /// rather than one hostile segment.+ #[test]+ fn a_stroke_is_built_only_as_far_as_the_caller_will_look() {+ let f = frame(4000, 4000);+ // Twenty long sweeps across the output: tens of thousands of dabs between them.+ let points: Vec<Point> =+ (0..20).map(|i| if i % 2 == 0 { Point::new(0.02, 0.02 + i as f64 * 0.04) } else { Point::new(0.98, 0.02 + i as f64 * 0.04) }).collect();+ let s = BrushStroke { points, size: 0.002, feather: 50.0, flow: 100.0, density: 100.0, ..Default::default() };++ let whole = brush_dabs(&s, &f, 4000, 4000);+ assert!(whole.dabs.len() > 20_000, "the stroke really is large: {}", whole.dabs.len());+ assert!(whole.dabs.len() <= MAX_STROKE_DABS);++ // Each caller gets what it asked for and no more, however large the stroke is. 4097 and+ // 200_001 are what the GPU path and the Auto Mask spot window now ask for.+ for max in [1usize, 2, 4097, 200_001] {+ let got = brush_dabs_within(&s, &f, 4000, 4000, max);+ assert!(got.dabs.len() <= max, "asked for at most {max}, built {}", got.dabs.len());+ assert_eq!(got.r, whole.r, "the brush itself is unchanged");+ }++ // A budget the stroke never reaches changes nothing: it only ever truncates.+ let generous = brush_dabs_within(&s, &f, 4000, 4000, whole.dabs.len() + 1000);+ assert_eq!(generous.dabs, whole.dabs, "an unreached budget leaves the stroke alone");++ // The guarantee the callers rely on: a result short of the budget was never truncated,+ // so it is the stroke itself. Both callers ask for one more than they will accept, so+ // anything they keep is identical to what they drew before this change, and anything+ // truncated is something they were going to reject anyway.+ //+ // A truncated one is not a prefix: running out of room makes a segment lay its remaining+ // dabs further apart rather than stop mid-segment, which is how `push_dabs_counted`+ // already behaved at MAX_STROKE_DABS. That only ever reaches a caller that rejects it.+ let cut = brush_dabs_within(&s, &f, 4000, 4000, 500);+ assert_eq!(cut.dabs.len(), 500, "a stroke past the budget fills it exactly");+ for max in [700usize, 5_000, whole.dabs.len()] {+ let got = brush_dabs_within(&s, &f, 4000, 4000, max);+ if got.dabs.len() < max {+ assert_eq!(got.dabs, whole.dabs, "a result short of its budget is the whole stroke");+ }+ }+ }+/// Issue #517: dabs along a long segment (a fast stroke: two pointer samples far apart) are at/// most [`dab_spacing`] apart, painting dab by dab (the live stroke) or the whole path at once/// (the committed one).diff --git a/crates/pipeline/src/spots.rs b/crates/pipeline/src/spots.rsindex 315f7f956..a875ffb7f 100644--- a/crates/pipeline/src/spots.rs+++ b/crates/pipeline/src/spots.rs@@ -206,7 +206,9 @@ pub fn window_for_reads_checked(// refine the stroke over a couple of radii: each dab matters to pixels within 2.5 radiilet mut dab_boxes: Vec<[f64; 4]> = Vec::new();for st in autos {- let dabs = crate::masks::brush_dabs(st, frame, full_w, full_h);+ // One more than the window takes, so a stroke past it is still recognised as past it+ // without the other 1.8 million dabs being built first (#1520).+ let dabs = crate::masks::brush_dabs_within(st, frame, full_w, full_h, MAX_DABS_CONSIDERED + 1);let r = dabs.r;if dabs.dabs.len() > MAX_DABS_CONSIDERED {continue;