perf(vello_common): Cull Bèziers path elements during flattening

This conservatively checks whether Bèzier path elements we're about to
flatten are outside the viewport. If they are fully to the right, top,
or bottom of the viewport, the Bèzier does not impact pixel coverage or
coarse winding at all, and can be ignored.

If it is fully to the left, it does impact pixel coverage and coarse
winding, but only the element's start and endpoint y-values matter, not
the exact shape, meaning we can just yield a line rather than finely
flattening.

If more or less everything ends up to be in the viewport, the additional
calculation is wasted and increases flattening time by ~3%.

If geometry ends up culled, flattening and tiling times can be reduced
significantly, but this is of course workload-dependent.

The following two Ghostscript Tiger's have their viewboxes reduced to
`50 50 100 100` and `90 90 20 20`, down from `0 0 200 200`. Their
flattening time is reduce by 52% and 90% respectively, and their tiling
time by 22% and 60%.

Flattening timings:

```
flatten/Ghostscript_Tiger
                        time:   [209.94 µs 210.21 µs 210.51 µs]
                        change: [+2.6850% +3.1753% +3.6309%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 5 outliers among 100 measurements (5.00%)
  4 (4.00%) high mild
  1 (1.00%) high severe
flatten/Ghostscript_Tiger-viewboxed
                        time:   [97.189 µs 97.287 µs 97.399 µs]
                        change: [-52.787% -52.650% -52.514%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 8 outliers among 100 measurements (8.00%)
  6 (6.00%) high mild
  2 (2.00%) high severe
flatten/Ghostscript_Tiger-viewboxed-extreme
                        time:   [19.722 µs 19.741 µs 19.761 µs]
                        change: [-90.311% -90.280% -90.255%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 8 outliers among 100 measurements (8.00%)
  7 (7.00%) high mild
  1 (1.00%) high severe
flatten/paris-30k       time:   [12.740 ms 12.764 ms 12.788 ms]
                        change: [+2.6014% +3.3631% +4.0837%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 3 outliers among 100 measurements (3.00%)
  3 (3.00%) high mild
```

Tiling timings:

```
tile/Ghostscript_Tiger  time:   [175.39 µs 175.79 µs 176.28 µs]
                        change: [-0.4403% -0.0016% +0.4400%] (p = 1.00 > 0.05)
                        No change in performance detected.
Found 1 outliers among 50 measurements (2.00%)
  1 (2.00%) high mild
tile/Ghostscript_Tiger-viewboxed
                        time:   [78.932 µs 79.147 µs 79.409 µs]
                        change: [-23.209% -22.803% -22.369%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 5 outliers among 50 measurements (10.00%)
  1 (2.00%) high mild
  4 (8.00%) high severe
tile/Ghostscript_Tiger-viewboxed-extreme
                        time:   [13.378 µs 13.390 µs 13.405 µs]
                        change: [-60.417% -60.306% -60.199%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 6 outliers among 50 measurements (12.00%)
  2 (4.00%) high mild
  4 (8.00%) high severe
tile/paris-30k          time:   [20.970 ms 21.001 ms 21.034 ms]
                        change: [-0.4881% -0.2397% +0.0108%] (p = 0.07 > 0.05)
                        No change in performance detected.
Found 1 outliers among 50 measurements (2.00%)
  1 (2.00%) high mild
```

Author: tomcur

sparse_strips/vello_bench/src/data.rs

@@ -86,6 +86,8 @@ impl DataItem {
                 path.transform,
                 &mut temp_buf,
                 &mut FlattenCtx::default(),
+                self.width,
+                self.height,
             );
             line_buf.extend(&temp_buf);
         }
@@ -103,6 +105,8 @@ impl DataItem {
                 &mut temp_buf,
                 &mut FlattenCtx::default(),
                 &mut StrokeCtx::default(),
+                self.width,
+                self.height,
             );
             line_buf.extend(&temp_buf);
         }

sparse_strips/vello_bench/src/flatten.rs

@@ -33,6 +33,8 @@ pub fn flatten(c: &mut Criterion) {
                             path.transform,
                             &mut temp_buf,
                             &mut flatten_ctx,
+                            $item.width,
+                            $item.height,
                         );
                         line_buf.extend(&temp_buf);
                     }
@@ -44,6 +46,8 @@ pub fn flatten(c: &mut Criterion) {
                             Affine::IDENTITY,
                             &mut temp_buf,
                             &mut flatten_ctx,
+                            $item.width,
+                            $item.height,
                         );
                         line_buf.extend(&temp_buf);
                     }

sparse_strips/vello_common/src/flatten.rs

@@ -34,6 +34,16 @@ impl Point {
     }
 }
 
+impl From<crate::kurbo::Point> for Point {
+    #[inline(always)]
+    fn from(value: crate::kurbo::Point) -> Self {
+        Self {
+            x: value.x as f32,
+            y: value.y as f32,
+        }
+    }
+}
+
 impl core::ops::Add for Point {
     type Output = Self;
 
@@ -81,8 +91,10 @@ pub fn fill(
     affine: Affine,
     line_buf: &mut Vec<Line>,
     ctx: &mut FlattenCtx,
+    width: u16,
+    height: u16,
 ) {
-    dispatch!(level, simd => fill_impl(simd, path, affine, line_buf, ctx));
+    dispatch!(level, simd => fill_impl(simd, path, affine, line_buf, ctx, width, height));
 }
 
 /// Flatten a filled bezier path into line segments.
@@ -93,12 +105,10 @@ pub fn fill_impl<S: Simd>(
     affine: Affine,
     line_buf: &mut Vec<Line>,
     flatten_ctx: &mut FlattenCtx,
+    width: u16,
+    height: u16,
 ) {
     line_buf.clear();
-    let iter = path.into_iter().map(
-        #[inline(always)]
-        |el| affine * el,
-    );
 
     let mut lb = FlattenerCallback {
         line_buf,
@@ -107,7 +117,7 @@ pub fn fill_impl<S: Simd>(
         is_nan: false,
     };
 
-    crate::flatten_simd::flatten(simd, iter, TOL, &mut lb, flatten_ctx);
+    crate::flatten_simd::flatten(simd, affine, path, TOL, &mut lb, flatten_ctx, width, height);
 
     // A path that contains NaN is ill-defined, so ignore it.
     if lb.is_nan {
@@ -125,6 +135,8 @@ pub fn stroke(
     line_buf: &mut Vec<Line>,
     flatten_ctx: &mut FlattenCtx,
     stroke_ctx: &mut StrokeCtx,
+    width: u16,
+    height: u16,
 ) {
     // TODO: Temporary hack to ensure that strokes are scaled properly by the transform.
     let tolerance = TOL
@@ -134,7 +146,15 @@ pub fn stroke(
             .max(1.);
 
     expand_stroke(path, style, tolerance, stroke_ctx);
-    fill(level, stroke_ctx.output(), affine, line_buf, flatten_ctx);
+    fill(
+        level,
+        stroke_ctx.output(),
+        affine,
+        line_buf,
+        flatten_ctx,
+        width,
+        height,
+    );
 }
 
 /// Expand a stroked path to a filled path.
@@ -161,13 +181,14 @@ impl Callback for FlattenerCallback<'_> {
             LinePathEl::MoveTo(p) => {
                 self.is_nan |= p.is_nan();
 
-                self.start = Point::new(p.x as f32, p.y as f32);
-                self.p0 = self.start;
+                let p = p.into();
+                self.start = p;
+                self.p0 = p;
             }
             LinePathEl::LineTo(p) => {
                 self.is_nan |= p.is_nan();
 
-                let p = Point::new(p.x as f32, p.y as f32);
+                let p = p.into();
                 self.line_buf.push(Line::new(self.p0, p));
                 self.p0 = p;
             }

sparse_strips/vello_common/src/flatten_simd.rs

@@ -8,7 +8,7 @@
 use crate::flatten::TOL_2;
 #[cfg(not(feature = "std"))]
 use crate::kurbo::common::FloatFuncs as _;
-use crate::kurbo::{CubicBez, ParamCurve, PathEl, Point, QuadBez};
+use crate::kurbo::{Affine, CubicBez, ParamCurve, PathEl, Point, QuadBez};
 use alloc::vec::Vec;
 use bytemuck::{Pod, Zeroable};
 use fearless_simd::*;
@@ -43,19 +43,27 @@ pub(crate) trait Callback {
 #[inline(always)]
 pub(crate) fn flatten<S: Simd>(
     simd: S,
+    affine: Affine,
     path: impl IntoIterator<Item = PathEl>,
     tolerance: f64,
     callback: &mut impl Callback,
     flatten_ctx: &mut FlattenCtx,
+    width: u16,
+    height: u16,
 ) {
     flatten_ctx.flattened_cubics.clear();
 
+    let width = width as f64;
+    let height = height as f64;
+
     let sqrt_tol = tolerance.sqrt();
     let mut closed = true;
     let mut start_pt = Point::ZERO;
     let mut last_pt = Point::ZERO;
 
     for el in path {
+        let el = affine * el;
+
         match el {
             PathEl::MoveTo(p) => {
                 if !closed && last_pt != start_pt {
@@ -74,8 +82,22 @@ pub(crate) fn flatten<S: Simd>(
             PathEl::QuadTo(p1, p2) => {
                 debug_assert!(!closed, "Expected a `MoveTo` before a `QuadTo`");
                 let p0 = last_pt;
-                // An upper bound on the shortest distance of any point on the quadratic Bezier
-                // curve to the line segment [p0, p2] is 1/2 of the maximum of the
+                // If the quadratic Bèzier is fully to the right, top, or bottom of the viewport,
+                // it does not impact pixel coverage or winding. We can ignore it. The following
+                // checks that conservatively by checking whether the bounding box of the Bèzier's
+                // control points is fully to the right, top, or bottom of the viewport.
+                if [p0, p1, p2].into_iter().all(|p| p.x > width)
+                    || [p0, p1, p2].into_iter().all(|p| p.y < 0.)
+                    || [p0, p1, p2].into_iter().all(|p| p.y > height)
+                {
+                    callback.callback(LinePathEl::MoveTo(p2));
+                }
+                // The following checks two things. First, if the quadratic Bèzier is fully to the
+                // left of the viewport, it may affect pixel coverage and winding, but its exact
+                // shape does not matter. It can be emitted as a line segment [p0, p2].
+                //
+                // Second, an upper bound on the shortest distance of any point on the quadratic
+                // Bèzier curve to the line segment [p0, p2] is 1/2 of the maximum of the
                 // endpoint-to-control-point distances.
                 //
                 // The derivation is similar to that for the cubic Bezier (see below). In
@@ -92,7 +114,9 @@ pub(crate) fn flatten<S: Simd>(
                 //
                 // The following takes the square to elide the square root of the Euclidean
                 // distance.
-                if f64::max((p1 - p0).hypot2(), (p1 - p2).hypot2()) <= 4. * TOL_2 {
+                else if [p0, p1, p2].into_iter().all(|p| p.x < 0.)
+                    || f64::max((p1 - p0).hypot2(), (p1 - p2).hypot2()) <= 4. * TOL_2
+                {
                     callback.callback(LinePathEl::LineTo(p2));
                 } else {
                     let q = QuadBez::new(p0, p1, p2);
@@ -112,7 +136,21 @@ pub(crate) fn flatten<S: Simd>(
             PathEl::CurveTo(p1, p2, p3) => {
                 debug_assert!(!closed, "Expected a `MoveTo` before a `CurveTo`");
                 let p0 = last_pt;
-                // An upper bound on the shortest distance of any point on the cubic Bezier
+                // If the cubic Bèzier is fully to the right, top, or bottom of the viewport, it
+                // does not impact pixel coverage or winding. We can ignore it. The following
+                // checks that conservatively by checking whether the bounding box of the Bèzier's
+                // control points is fully to the right, top, or bottom of the viewport.
+                if [p0, p1, p2, p3].into_iter().all(|p| p.x > width)
+                    || [p0, p1, p2, p3].into_iter().all(|p| p.y < 0.)
+                    || [p0, p1, p2, p3].into_iter().all(|p| p.y > height)
+                {
+                    callback.callback(LinePathEl::MoveTo(p3));
+                }
+                // The following checks two things. First, if the cubic Bèzier is fully to the
+                // left of the viewport, it may affect pixel coverage and winding, but its exact
+                // shape does not matter. It can be emitted as a line segment [p0, p3].
+                //
+                // Second, an upper bound on the shortest distance of any point on the cubic Bèzier
                 // curve to the line segment [p0, p3] is 3/4 of the maximum of the
                 // endpoint-to-control-point distances.
                 //
@@ -132,7 +170,9 @@ pub(crate) fn flatten<S: Simd>(
                 //
                 // The following takes the square to elide the square root of the Euclidean
                 // distance.
-                if f64::max((p0 - p1).hypot2(), (p3 - p2).hypot2()) <= 16. / 9. * TOL_2 {
+                else if [p0, p1, p2].into_iter().all(|p| p.x < 0.)
+                    || f64::max((p0 - p1).hypot2(), (p3 - p2).hypot2()) <= 16. / 9. * TOL_2
+                {
                     callback.callback(LinePathEl::LineTo(p3));
                 } else {
                     let c = CubicBez::new(p0, p1, p2, p3);

sparse_strips/vello_common/src/strip_generator.rs

@@ -102,6 +102,8 @@ impl StripGenerator {
             transform,
             &mut self.line_buf,
             &mut self.flatten_ctx,
+            self.width,
+            self.height,
         );
 
         self.generate_with_clip(aliasing_threshold, strip_storage, fill_rule, clip_path);
@@ -125,6 +127,8 @@ impl StripGenerator {
             &mut self.line_buf,
             &mut self.flatten_ctx,
             &mut self.stroke_ctx,
+            self.width,
+            self.height,
         );
         self.generate_with_clip(aliasing_threshold, strip_storage, Fill::NonZero, clip_path);
     }

sparse_strips/vello_common/src/tile.rs

@@ -1341,6 +1341,9 @@ mod tests {
 
     #[test]
     fn vertical_path_on_the_right_of_viewport() {
+        const VIEWPORT_WIDTH: u16 = 10;
+        const VIEWPORT_HEIGHT: u16 = 10;
+
         let path = BezPath::from_svg("M261,0 L78848,0 L78848,4 L261,4 Z").unwrap();
         let mut line_buf = vec![];
         fill(
@@ -1349,10 +1352,12 @@ mod tests {
             Affine::IDENTITY,
             &mut line_buf,
             &mut FlattenCtx::default(),
+            VIEWPORT_WIDTH,
+            VIEWPORT_HEIGHT,
         );
 
         let mut tiles = Tiles::new(Level::try_detect().unwrap_or(Level::fallback()));
-        tiles.assert_tiles_match(&line_buf, 10, 10, &[]);
+        tiles.assert_tiles_match(&line_buf, VIEWPORT_WIDTH, VIEWPORT_HEIGHT, &[]);
     }
 
     #[test]