1 / 38

Compact, Fast and Robust Grids for Ray Tracing

Compact, Fast and Robust Grids for Ray Tracing. Ares Lagae & Philip Dutré Katholieke Universiteit Leuven. Wednesday, 13 August. Contributions. Two memory-efficient representations for grids for ray tracing Compact grid method

masonb
Télécharger la présentation

Compact, Fast and Robust Grids for Ray Tracing

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Compact, Fast and Robust Gridsfor Ray Tracing Ares Lagae & Philip Dutré Katholieke Universiteit Leuven Wednesday, 13 August

  2. Contributions • Two memory-efficient representations for grids for ray tracing • Compact grid method  Optimal grid representation(1 word / cell, 1 word / object reference) • Hashed grid method  Applied perfect spatial hashing to grids for ray tracing • Simple and efficient

  3. Motivation • Acceleration structures for ray tracing  Minimize time to image • Time to image = build time + render time • Especially for dynamic scenes

  4. Motivation • Algorithms in general • CPU-bound • Execution time = f( CPU speed ) • Memory-bound • Execution time = f( memory access speed )  Accelerate by decreasing memory footprint  Minimize memory footprint • Especially for large models

  5. 0 1 2 0 0 1 1 2 2 Grid Data Structures • Grid and linearized grid 2D 2D C A B linearize 0 1 2 3 4 5 6 7 8 1D

  6. Grid Data Structures • Data structure using linked lists 0 1 2 3 4 5 6 7 8 B B A C C A C C B B • 1 word / cell • 2/3 words / object reference A

  7. : unused space Grid Data Structures • Data structure using dynamic arrays 0 1 2 3 4 5 6 7 8 2 0 2 1 2 1 2 1 4 3 2 2 2 1 2 1 2 1 B B A A B A C C B C C • 3 words / cell • 1-2 words / object reference

  8. Compact Grid • Data structure • Concatenate object lists, store begin index 0 1 2 3 4 4 4 5 6 7 8 0 0 1 2 3 3 3 3 3 3 3 6 8 9 10 11 B B A A B C B C A C C 0 1 2 3 3 3 3 3 4 4 4 4 5 5 5 6 7 8 9 10 11  1 word / cell, 1 word / object reference

  9. Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 1. Bound  Compute bounding box of objects  Determine grid resolution  Grid sizelinear in number of objects

  10. Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 2. Count  Compute size of object lists (1st pass) 0 1 2 3 4 5 6 7 8 0 1 1 1 3 2 1 1 1 0 1 2 3 4 5 6 7 8 9 10 11

  11. Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 3. Accumulate  Compute indices of object lists 0 1 2 3 4 5 6 7 8 0 1 2 3 3 3 6 8 9 10 11 0 1 2 3 4 5 6 7 8 9 10 11

  12. Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 4. Insert  Reversely insert the object references (2nd pass) 0 1 2 3 4 5 6 7 8 0 1 2 3 3 3 5 8 9 10 11 C 0 1 2 3 4 5 6 7 8 9 10 11

  13. Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 4. Insert  Reversely insert the object references (2nd pass) 0 1 2 3 4 5 6 7 8 0 1 2 3 3 3 4 8 9 10 11 B C 0 1 2 3 4 5 6 7 8 9 10 11

  14. Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 4. Insert  Reversely insert the object references (2nd pass) 0 1 2 3 4 5 6 7 8 0 1 2 3 3 3 3 8 9 10 11 A B C 0 1 2 3 4 5 6 7 8 9 10 11

  15. Compact Grid • Build algorithm (Bound – Count – Accumulate – Insert) 4. Insert  Reversely insert the object references (2nd pass) 0 1 2 3 4 5 6 7 8 0 0 1 2 3 3 3 6 8 9 10 B B A A B C B C A C C 0 1 2 3 4 5 6 7 8 9 10 11

  16. Compact Grid • Build algorithm • Time complexity  Linear in the number of objects • Space complexity  Linear in the number of objects • Traversal algorithm • Any grid traversal algorithm

  17. list array compact Results • Comparison to traditional grid data structures Memory usage Build time

  18. Hashed Grid • Reduce memory footprint even further • Fast build algorithm • Efficient access during traversal • Redundancy • Object lists?  no Experiments with object list compression failed • Cells?  yes Grid is sparse, up to 99% of the cells are empty

  19. Hashed Grid • Row displacement compression C 1 5 11 12 15

  20. Hashed Grid • Row displacement compression C O 1 5 11 12 15 H

  21. Hashed Grid • Row displacement compression C O 1 0 1 5 11 12 15 H H 1

  22. Hashed Grid • Row displacement compression C O 1 1 1 1 1 1 0 1 1 1 5 5 5 5 5 5 1 5 5 5 11 11 11 11 11 12 12 12 12 12 12 15 15 15 15 H 1 1 5 5

  23. Hashed Grid • Row displacement compression C O 1 1 1 1 1 1 1 0 1 1 1 1 1 5 5 5 5 5 5 5 5 1 5 5 5 5 11 11 11 11 11 11 1 11 11 11 12 12 12 12 12 12 12 12 12 15 15 15 15 15 15 H 1 5 11 11

  24. Hashed Grid • Row displacement compression C O 1 0 1 1 1 5 1 5 5 5 11 1 11 11 11 12 15 3 12 12 12 15 15 15 H 1 5 12 11 11 15 15

  25. Hashed Grid • Row displacement compression O 0 1 1 3 C[i,j]  H[O[i] + j] H 1 1 5 5 12 12 11 11 15

  26. Hashed Grid • Row displacement compression D O 0 1 1 3 |D| + |O| + |H| << |C| H 1 1 1 1 1 5 5 5 5 12 12 12 11 11 15

  27. Hashed Grid • Build algorithm • Bound • Compute domain bits • Compute hash function • Count • Accumulate • Insert • Time complexity: Added Now work directly on the hash table instead of the linearized cell array

  28. Results • Compact grid  Hashed grid • Scene: 3.64 M triangles, 124.84 MB • Memory object lists: 28.84 MB • Memory cells: 55.48 MB  6.20 MB • Build time: 0.39 s  0.72 s • Render time: 2.49 s  2.52 s Cruiser • Scene: 28.06 M triangles, 343.32 MB • Memory object lists: 69.78 MB • Memory cells: 152.75 MB  8.97 MB • Build time: 1.17 s  1.76 s • Render time: 1.55 s  1.43 s Thai Statue

  29. list array compact hashed Results • Comparison to traditional grid data structures Memory usage Build time

  30. Applications • Interactive ray tracing of dynamic scenes Scene: 260 K triangles - FPS: 8.38 FPS (512 x 512)

  31. Applications • Ray tracing large models (16 GB workstation) • Scene: 56.23 M triangles, 1.89 GB • Time to image: 7.55 s / 10.21 s • Memory usage: 1.17 GB / 379.94 MB David • Scene: 372.77 M triangles, 12.50 GB • Time to image: - / 60.75 s • Memory usage: - / 2.36 GB St. Matthew

  32. Conclusion & Future Work • Conclusion Two memory-efficient representations for grids for ray tracing • Compact grid method  Optimal grid representation(1 word / cell, 1 word / object reference) • Hashed grid method  Applied perfect spatial hashing to grids for ray tracing • Future Work • Extend to hierarchical grids • Extend to other acceleration structures

  33. Thanks! • Questions? http://www.cs.kuleuven.be/~ares/ Acknowledgments Ares Lagae is a Postdoctoral Fellow of the Research Foundation Flanders (FWO). The Stanford 3D Scanning Repository, The Digital Michelangelo Project, the bwfirt benchmark, Matthias Rolf, Bernhard Finkbeiner and Greg Ward.

  34. Robust Grid Traversal • Discard intersections outside of cell  Not robust {} {} {…} {…}

  35. Robust Grid Traversal • Discard intersections outside of cell  Not robust Regular grid traversal

  36. Robust Grid Traversal  Do not discard intersections outside of cell • Keep closest intersection, terminate after the intersection Regular grid traversal Robust grid traversal

  37. Parallelization • Using sort-middle approach of Ize et al. Asian Dragon Nature

More Related