linebender / gpu-stroke-expansion-paper Goto Github PK

This issue is to propose the figures for the paper.

1. A conceptual pipeline. First stage contains a number of encoded path segments, maybe one highlighted for expansion in subsequent stages (the others thinner/grayer). Next: approximation of the cubic with a sequence of Euler spirals (each a different color). Then maybe show the (exact) parallel curves of those spirals, colors matching. Finally show the flattening.

2. Images to show the stroke encoding. Slide 6 from RustLab2023 talk may be a starting point, but it doesn't show caps/joins.

3. Cubic to Euler error metric
   a. Probably a diagram showing cubic and ES superimposed, with common thetas, and an arrow showing the point of maximum distance.
   b. Double-parabola construction (see Cleaner parallel curves with Euler spirals
   c. Fit of double-parabola over theta_0, theta_1 space (same link as above)
   d. Heatmap plot of actual Fréchet distance vs estimate, for d_0, d_1 slice of parameter space, theta_0 and theta_1 fixed

4. Maybe a figure to support unrolled recursion? Not obvious what this should look like

5. Handling of cusp case. Show cubic w/cusp, highlight ES with 180 degree turn, likely also show parallel curves

6. Subdivision density
   a. Supporting figure for subdivision density, maybe the one from Flattening quadratic Béziers
   b. sqrt(|1-x^2|) (this figure is already in the paper) - it can be smaller though
   c. Exact and approximate integral of above (this figure is already in the paper)

7. Evolutes
   a. Euler spiral and its evolute (see wiki page), plus subdivisions for flattening
   b. Simplified Fig 11 from Nehab

8. Triangle strip as alternate output

9. Performance figures; follow Fig 15 from Nehab

Histograms, Counts

1. Cubic -> ES(PC) counts
2. ES(PC) -> Line Segments
3. ES(PC) -> Circular Arc Segments
4. flatten max and average cubic->euler iteration counts per invocation

I suggest using the "stills" data set from Nehab'20

GPU Perf.

For GPU timings, I'm planning to use the fine-grained (per-pipeline) timer queries in wgpu-profiler. This can be readily instrumented to output averages across a large sample count. This feature is supported on Vulkan and works with my Ubuntu NVIDIA RTX4090 setup. Fine-grained queries don't seem to work on Metal, so we'll need to rely on XCode to produce these on M1, which is harder to automate (unless maybe there's a path to getting wgpu-profiler to work).

For raw GPU timings we'll use the "timings" data set from Nehab'20 plus stress tests from the Vello test-scenes (trickycubicstrokes, mmark, longpathdash, many_draw_objects (zoomed in)

1. Raw average flatten time
2. flatten time as fraction of overall render time
3. flatten with GPU_STROKES = false?
4. End-to-end frame timing comparison (against other renderers TBD)