Ray-casting Algebraic Surfaces using the Frustum Form. Eurographics 2008 Crete, Thursday April 17.

Transcription

1 Ray-casting Algebraic Surfaces using the Frustum Form Martin Reimers Johan Seland Eurographics 2008 Crete, Thursday April 17.

2 Algebraic Surfaces Zero set of polynomial f : R 3 R f (x, y, z) = f ijk x i y j z k = 0 0 i+j+k d Sphere: x 2 + y 2 + z 2 1 = 0 Classic field of mathematics Very compact representation Renewed interest as geom. rep.

3 Ray-casting Overview Given a view frustum and screen resolution (m + 1) (n + 1) Let each pixel correspond to a ray r pq : [0, 1] R 3 Find first intersection i.e. Back plane n + 1 f (r pq (t)) = 0 Find final pixel color Little brother of ray-tracing m + 1

4 Ray-casting Overview Given a view frustum and screen resolution (m + 1) (n + 1) Let each pixel correspond to a ray r pq : [0, 1] R 3 Find first intersection i.e. Back plane n + 1 f (r pq (t)) = 0 Find final pixel color Little brother of ray-tracing m + 1

5 Ray-casting Overview Given a view frustum and screen resolution (m + 1) (n + 1) Let each pixel correspond to a ray r pq : [0, 1] R 3 Find first intersection i.e. Back plane n + 1 f (r pq (t)) = 0 Find final pixel color Little brother of ray-tracing m + 1

6 Ray-casting: Challenges Conceptually simple - computationally challenging Working directly on f is expensive Better approach: use univariate representation for each ray How to find the ray equations (in Bernstein form) f (r pq (t)) = c pqr Br d (t) = 0 How to find the roots? Embarrassingly parallel - use GPU?

7 Outline Ray coefficient computation Root finding Implementation details Results and Conclusion

8 Parameterizing the View Frustum Idea: Parameterize the view frustum over the unit cube by L(u, v, w) = 1,1,1 i,j,k=0 v ijk B 1 i (u)b 1 j (v)b 1 k (w) w v u

9 Parameterizing the View Frustum Idea: Parameterize the view frustum over the unit cube by L(u, v, w) = 1,1,1 i,j,k=0 v ijk B 1 i (u)b 1 j (v)b 1 k (w) w v u (u, v, 0) is mapped to the front plane

10 Parameterizing the View Frustum Idea: Parameterize the view frustum over the unit cube by L(u, v, w) = 1,1,1 i,j,k=0 v ijk B 1 i (u)b 1 j (v)b 1 k (w) w v u (u, v, 0) is mapped to the front plane (u, v, 1) is mapped to the back plane

11 Parameterizing the View Frustum Idea: Parameterize the view frustum over the unit cube by L(u, v, w) = 1,1,1 i,j,k=0 v ijk B 1 i (u)b 1 j (v)b 1 k (w) v L u w (u, v, 0) is mapped to the front plane (u, v, 1) is mapped to the back plane Rays are mapped to rays (but no longer parallel)

12 The Frustum Form (FF) We call g = f L : [0, 1] 3 R the Frustum Form v f = 0 u L w

13 The Frustum Form (FF) We call g = f L : [0, 1] 3 R the Frustum Form g = 0 v f = 0 u L w g = 0 corresponds to f = 0

14 The Frustum Form (FF) We call g = f L : [0, 1] 3 R the Frustum Form g = 0 v f = 0 u L w g = 0 corresponds to f = 0 g is a tri-degree d polynomial

15 The Frustum Form (FF) We call g = f L : [0, 1] 3 R the Frustum Form g = 0 v f = 0 u L w g = 0 corresponds to f = 0 g is a tri-degree d polynomial Bernstein form g(u, v, w) = d,d,d i,j,k=0 g ijkb d i (u)b d j (v)bd k (w)

16 The Frustum Form (FF) We call g = f L : [0, 1] 3 R the Frustum Form g = 0 v f = 0 u L w g = 0 corresponds to f = 0 g is a tri-degree d polynomial Bernstein form g(u, v, w) = d,d,d i,j,k=0 g ijkb d i (u)b d j (v)bd k (w) Rays are iso-parametric (parallel), ray polynomials of degree d

17 Ray coefficients r pq (t) w v For pixel (p, q) this yields u g(p/m, q/n, w) = d,d,d i,j,k=0 g ijk B d i (p/m)b d j (q/n)b d k (w)

18 Ray coefficients r pq (t) w v For pixel (p, q) this yields g(p/m, q/n, w) = u = d,d,d i,j,k=0 g ijk B d i (p/m)b d j (q/n)b d k (w) d d,d g ijk Bi d ( p m )Bd j ( q n ) B k d (w) k=0 i,j=0 } {{ } c pqk

19 Ray coefficients r pq (t) w v For pixel (p, q) this yields g(p/m, q/n, w) = u = d,d,d i,j,k=0 g ijk B d i (p/m)b d j (q/n)b d k (w) d d,d g ijk Bi d ( p m )Bd j ( q n ) B k d (w) k=0 i,j=0 } {{ } c pqk c pqk d f (r pq (t)) = c pqk Bk d (t) k=0 c pqk are the ray coefficients

20 Outline Ray coefficient computation Root finding Implementation details Results and Conclusion

21 Bernstein Polynomials c pq2 c pq0 c c pq3 pq1 t Ray equations in Bernstein form f (r pq (t)) = d k=0 c pqkbk d(t) Bk d(t) = ( ) d k t k (1 t) d k Numerically optimal [Farouki] Coefficients form control polygon

22 Bernstein Polynomials c pq2 c pq0 c c pq3 pq1 t Ray equations in Bernstein form f (r pq (t)) = d k=0 c pqkbk d(t) Bk d(t) = ( ) d k t k (1 t) d k Numerically optimal [Farouki] Coefficients form control polygon Properties of Control Polygon The function is approximated by the C. P. Variation Diminishing Property #of zeros in polynomial #of zeros in C. P. Control Polygon can be subdivided/refined

23 Numerical Root Finding Algorithms: Repeated refinement of control polygon, either Bézier subdivision [Lane&Riesenfeld 81,Rockwood et Al 89] B-Spline knot insertion [Mørken&Reimers 07]

24 Numerical Root Finding Algorithms: Repeated refinement of control polygon, either Bézier subdivision [Lane&Riesenfeld 81,Rockwood et Al 89] B-Spline knot insertion [Mørken&Reimers 07]

25 Numerical Root Finding Algorithms: Repeated refinement of control polygon, either Bézier subdivision [Lane&Riesenfeld 81,Rockwood et Al 89] B-Spline knot insertion [Mørken&Reimers 07]

26 Numerical Root Finding Algorithms: Repeated refinement of control polygon, either Bézier subdivision [Lane&Riesenfeld 81,Rockwood et Al 89] B-Spline knot insertion [Mørken&Reimers 07]

27 Numerical Root Finding Algorithms: Repeated refinement of control polygon, either Bézier subdivision [Lane&Riesenfeld 81,Rockwood et Al 89] B-Spline knot insertion [Mørken&Reimers 07]

28 Numerical Root Finding Algorithms: Repeated refinement of control polygon, either Bézier subdivision [Lane&Riesenfeld 81,Rockwood et Al 89] B-Spline knot insertion [Mørken&Reimers 07]

29 Numerical Root Finding Algorithms: Repeated refinement of control polygon, either Bézier subdivision [Lane&Riesenfeld 81,Rockwood et Al 89] B-Spline knot insertion [Mørken&Reimers 07]

30 Numerical Root Finding Algorithms: Repeated refinement of control polygon, either Bézier subdivision [Lane&Riesenfeld 81,Rockwood et Al 89] B-Spline knot insertion [Mørken&Reimers 07]

31 Properties of rootfinders Easy to implement Robust and automatic (don t miss any zeros) Quadratic convergence to simple zeros (like Newtons method) Recent extension [Mørken&Reimers] converge quadratically to multiple zeros (e.g. near silhouettes) Knot insertion framework is very flexible, and allow for variations: Prime using neighbor rays/previous frames ( Coherency ) Detect critical points, search for singularities.

32 Anti-aliasing Problem: Silhouette edges fall between rays w At silhouettes g(z) = 0, g w (z) = 0 z p 1 z 0 p 2 v

33 Anti-aliasing Problem: Silhouette edges fall between rays w At silhouettes g(z) = 0, g w (z) = 0 When p 1 miss and p 2 hits Start from minima of g(p 1 ) Use Newton on (g(s), g w (s)) z p 1 z 0 p 2 v

34 Anti-aliasing Problem: Silhouette edges fall between rays w At silhouettes g(z) = 0, g w (z) = 0 When p 1 miss and p 2 hits Start from minima of g(p 1 ) Use Newton on (g(s), g w (s)) Find pixel color by Wus method color(p1 ) = (1 α) color(p 2 ) z p 1 α z 0 p 2 v

35 Anti-aliasing Problem: Silhouette edges fall between rays w At silhouettes g(z) = 0, g w (z) = 0 When p 1 miss and p 2 hits Start from minima of g(p 1 ) Use Newton on (g(s), g w (s)) Find pixel color by Wus method color(p1 ) = (1 α) color(p 2 ) z Internal silhouettes 25% - 50% performance loss p 1 α z 0 p 2 v

36 Outline Ray coefficient computation Root finding Implementation details Results and Conclusion

37 Implementation Use GPUs for parallelism Our algorithm is designed for efficiency on modern hardware Precompute as much as possible Split computations between CPU and GPU for efficiency Also allows controlling the precision We use NVidias CUDA API Same source code for GPU and CPU versions No OpenGL/DirectX involved

38 Calculating the Frustum Form Coefficients We find the coefficients g ijk by interpolation Choose (d + 1) 3 interpolation points v u w

39 Calculating the Frustum Form Coefficients We find the coefficients g ijk by interpolation Choose (d + 1) 3 interpolation points Form tri-tensor F by evaluating f L d g ijk Bi d (u p )Bj d (v q )Bk d (w r ) i,j,k=0 = f (L(u p, v q, w r )) f 022 f 122 f 222 f 021 f 121 f 221 f 020 f 120 f 220 f 012 f 112 f 212 f 011 f 111 f 211 f 010 f 110 f 210 f 002 f 102 f 202 f 001 f 101 f 201 f 000 f 100 f 200

40 Calculating the Frustum Form Coefficients We find the coefficients g ijk by interpolation Choose (d + 1) 3 interpolation points Form tri-tensor F by evaluating f L d g ijk Bi d (u p )Bj d (v q )Bk d (w r ) i,j,k=0 = f (L(u p, v q, w r )) Calculate matrix Ω u = (Bi d (u j )) f 022 f 122 f 222 f 021 f 121 f 221 f 020 f 120 f 220 f 012 f 112 f 212 f 011 f 111 f 211 f 010 f 110 f 210 f 002 f 102 f 202 f 001 f 101 f 201 f 000 f 100 f 200 B0 d (u 0) Bd d(u 0)..... B0 d(u d) Bd d(u d)

41 Calculating the Frustum Form Coefficients We find the coefficients g ijk by interpolation Choose (d + 1) 3 interpolation points Form tri-tensor F by evaluating f L d g ijk Bi d (u p )Bj d (v q )Bk d (w r ) i,j,k=0 = f (L(u p, v q, w r )) Calculate matrix Ω u = (Bi d (u j )) In Einstein notation Ω u ipω v jqω w kr G ijk = F pqr f 022 f 122 f 222 f 021 f 121 f 221 f 020 f 120 f 220 f 012 f 112 f 212 f 011 f 111 f 211 f 010 f 110 f 210 f 002 f 102 f 202 f 001 f 101 f 201 f 000 f 100 f 200 B0 d (u 0) Bd d(u 0)..... B0 d(u d) Bd d(u d)

42 Frustum Form Coefficients cont. Ω u ip Ωv jq Ωw kr G ijk = F pqr Solve as a nested sequence of matrix products G ijk = (Ω w ) 1 kr (Ωv ) 1 jq (Ωu ) 1 ip F prq Ω 1 -matrices are only dependent on d precompute Size of system is small (d + 1) 3 perform in double on CPU Use Chebyshev points for numerical stability Not dependent on f to be a polynomial

43 Ray coefficient computation f (r pq ) = d d,d Bi d ( p m )g ijkbj d ( q n ) B k d (w) k=0 i,j=0 } {{ } c pqk Implemented as matrix products on the GPU

44 Ray coefficient computation f (r pq ) = d d,d Bi d ( p m )g ijkbj d ( q n ) B k d (w) k=0 i,j=0 } {{ } c pqk Implemented as matrix products on the GPU Dedicated CUDA kernel computes 4 slices in one pass d + 1 d + 1 m C k = Bi d G k (Bj d)t m n d + 1 n

45 Root finding computations Each ray is processed by a CUDA thread Memory layout crucial to maximize performance Ensure that memory reads/writes are coalesced Degree d is template parameter to specialize algorithms template<int d> float decasteljau( float t, float* CP ) { float *R[d+1]; float *L[d+1];. } Avoid idle threads by spatial regularity Rays 8 8 threadblock converge in same iteration#

46 Outline Ray coefficient computation Root finding Implementation details Results and Conclusion

47 d = 5, 74 FPS d = 6, 60 FPS d = 6, 45 FPS d = 8, 33 FPS d = 10, 12 FPS d = 16, 3.1 FPS

48 Conclusion: Benefits of the Frustum Form For fixed m, n, d precompute basis functions Reduce algorithmic complexity Evaluation of c pqk requires (d + 1) 2 muls/adds. Evaluation of f requires (d + 1)(d + 2)(d + 3)/6 muls/adds. Univariate ray equations for root finding f (r pq (t)) = d c pqk Bk d (t) = 0 k=0 Bernstein form for robust root finding Sample based methods might miss thin features Interval Methods[Knoll et. al.] are more robust Fast for sparse polynomials

49 Future Work Topologically correct ray-casting Beam tracing Mathematical exploration Surface intersections Singularity detection Performance and stability High degrees use blossoming to find Frustum Form coeffs. Sort rays based on estimated complexity

50 Thank you for listening! Questions?