Newer
Older
# Project Group: Vector Graphics on Modern Hardware (still accepting more students)
[Presentation slides](https://git.cs.uni-paderborn.de/vgmh/info/-/blob/main/talk/talk.pdf)
{width=350}
Vector graphics are omnipresent in user interfaces.
In fact, you are looking at rendered vector graphics right now!
Every letter in this text is made up by vector graphics, but also more complex graphics (e.g. the SVG tiger above).
Still, rendering vector graphics in real time efficiently is still not a fully solved problem.
In the past, vector graphics were just rendered on the CPU, but with high resolutions, fluid animations, and power requirements of mobile hardware, that is no longer feasible.
Hence, we would like to render on the GPU.
The most natural approach is to tesselate vector graphics to triangles and leverage the traditional raster pipeline of the GPU.
However, this still requires rasterization on the CPU.
Another issue is aliasing.
Of course, we can still use MSAA like in 3D rendering, which comes with a significant performance penalty, but quality also suffers when a very thin pass "snakes" between the [sample points](https://learn.microsoft.com/en-us/windows/win32/api/d3d11/ne-d3d11-d3d11_standard_multisample_quality_levels), causing discontinuities in the path (see this Chromium [issue](https://bugs.chromium.org/p/chromium/issues/detail?id=1287455#c1)).
The best quality is achieved with analytic anti-aliasing, where the intersection area of shapes and pixels is calculated.
We are interested in rendering vector graphics on the GPU and comparing different approaches on modern hardware.
Hence we will not just nVidia CUDA (like e.g. [GLFN14]), but a cross-platform interface like Vulkan or WebGPU/wgpu.
Science:
- Understand the current state of the art. This includes both academic publications, as well as practical implementations. Specifically [vello](https://github.com/linebender/vello) seems very interesting algorithmically, but there is no academic publication.
- Implement one or multiple techniques (depending on number of participants and time). Define a common interface so that the different implementations can be tested.
- Perhaps develop your own rendering algorithm, or modifications. Also consider scenes with animations and how to do as little work as possible when the scene changes slightly.
- Develop benchmarks to compare implementations (your own and existing). Compare visual fidelity and performance.
See [LP05, NH08, GLFN14, LHZ16] for prior work.
Programming:
- Build a collaborative digital whiteboard platform using your own renderer.
- Use a modular architecture so that you can compare different renderers in practice.
- Publish the software under an open source license, so other universities can develop it further.
- Try to port to all platforms (Linux, Windows, Mac, Android, iOS, web)
- Use techniques suitable for cross platform applications. I.e., avoid platform specific SDKs like Metal, DirectX, AppKit, CUDA, ...
- I don't expect that you really port to all platforms, but it should at least be possible without major difficulties.
- Pen input
- Google's [ink-stroke-modeler](https://github.com/google/ink-stroke-modeler) works pretty well for smoothing
- Still, constructing shapes for rendering from pen inputs is non-trivial and there are different trade-offs one can make.
- PDF integration via [PDFium](https://pdfium.googlesource.com/pdfium/)
- If you want to publish on iOS, this is really your only choice for a PDF library since GPL/AGPL is supposedly incompatible with the App Store.
## Skills
During the project group, you will learn and apply the following skills:
- Programming in a system programming language like Rust, C, C++
- GPU programming (e.g. CUDA, OpenGL, Vulkan, Metal, DirectX, wgpu)
- Read and understand scientific papers
- Graphics rendering
- [LP05] Charles Loop and Jim Blinn. 2005. Resolution independent curve rendering using programmable graphics hardware. ACM Trans. Graph. 24, 3 (July 2005), 1000–1009. https://doi.org/10.1145/1073204.1073303
- [NH08] Diego Nehab and Hugues Hoppe. 2008. Random-access rendering of general vector graphics. ACM Trans. Graph. 27, 5, Article 135 (December 2008), 10 pages. https://doi.org/10.1145/1409060.1409088
- [GLFN14] Francisco Ganacim, Rodolfo S. Lima, Luiz Henrique de Figueiredo, and Diego Nehab. 2014. Massively-parallel vector graphics. ACM Trans. Graph. 33, 6, Article 229 (November 2014), 14 pages. https://doi.org/10.1145/2661229.2661274 https://w3.impa.br/~diego/projects/GanEtAl14/
- [LHZ16] Rui Li, Qiming Hou, and Kun Zhou. 2016. Efficient GPU path rendering using scanline rasterization. ACM Trans. Graph. 35, 6, Article 228 (November 2016), 12 pages. https://doi.org/10.1145/2980179.2982434 http://kunzhou.net/zjugaps/pathrendering/
- [1] Ghostscript Tiger, [AGPLv3](https://git.ghostscript.com/?p=ghostpdl.git;a=blob_plain;f=doc/COPYING;hb=HEAD)
- [2] Raph Levien. 2019. 2D Graphics on Modern GPU (blog post).https://raphlinus.github.io/rust/graphics/gpu/2019/05/08/modern-2d.html
- [3] Diego Nehab. 2D Computer Graphics (course). 2020.https://w3.impa.br/~diego/teaching/vg/
- [4] Google. The Raster Tragedy in Skia (blog post). https://skia.org/docs/dev/design/raster_tragedy/
- [5] Nicolas Silva. List of vector graphics rendering approaches: https://github.com/nical/lyon/wiki/Related-projects
- [6] Beat Stamm. The Raster Tragedy at Low-Resolution Revisited: Opportunities and Challenges beyond “Delta-Hinting”. http://rastertragedy.com/
- [7] Stylus Labs. https://github.com/styluslabs/nanovgXC (rendering framework of the https://www.styluslabs.com/ software)
[Create issue](https://git.cs.uni-paderborn.de/vgmh/info/-/issues/new) or email dorianDOTrudolphATupbDOTde