Volume Rendernig

1. Volume Rendernig CSE 781 Winter 05 Han-Wei Shen

2. Visualization Process sensors simulation database raw data Transformation images

3. Visualization Pipeline sensors simulation database raw data filter vis data mapping Renderable primitives rendering images

4. Visualization Pipeline sensors simulation database raw data • Denoising • Decimation • Multiresolution • Mesh generation • etc filter vis data Renderable primitives images

5. Visualization Pipeline sensors simulation database raw data • Geometry: • Line • Surface • Voxel • Attributes: • Color • Opacity • Texture vis data mapping Renderable primitives images

6. Visualization Pipeline sensors simulation database raw data • Surface rendering • Volume rendering • Point based rendering • Image based rendering • NPR vis data Renderable primitives rendering images

7. Volume Rendering • Goal: visualize three-dimensional functions • Measurements (medical imaging) • Numerical simulation output • Analytic functions

8. Data Representation 3D volume data are represented by a finite number of cross sectional slices (a stack of images) N x 2D arraies = 3D array

9. A voxel is a cubic cell, which has a single value cover the entire cubic region A voxel is a data point at a corner of the cubic cell The value of a point inside the cell is determined by interpolation Data Representation (2) What is a Voxel? – Two definitions

10. Important Steps • Sampling and Reconstruction • Classification • Shading • Optical model By Ray Casting or Texture Hardware

11. Ray Casting Basic Idea • Data are defined at the corners • of each cell (voxel) • The data value inside the • voxel is determined using • tri-linear interpolation • No ray position round-off is • needed when sampling • Accumulate colors and opacities • along the ray path c1 c2 c3

12. Volume Rendering Pipeline Acquired values f0(xi) Prepared values f1(xi) Compositing Image Pixels classification voxel opacity a(x) sample opacities Cs(x) shading voxel colors Ci(x) sample colors Cs(x)

13. Tri-linear Interpolation • Use 7 linear interpolations • Interpolate both value and • gradient • Map to color and • opacity c2

14. Shading and Classification • - Shading: compute a color for each data point in the • volume • - Classification: Compute an opacity for each data point • in the volume • Done by table lookup (transfer function) f(xi) C(xi), a(xi)

15. Shading • Use a phong illumination model • Light (color) = ambient + diffuse + specular • C(x) = Cp * Ka + Cp / (K1 + K2* d(x)) * • (Kd * (N(x) . L + Ks * (N(x) . H )^n ) • Cp: color of light • ka,kd,ks: ambient, diffusive, specular coefficient • K1,K2: constant (used for depth attenuation) • N(x): normal at x

16. Normal estimation • How to compute N(x)? • Compute the gradient at each corner • Interpolate the normal using central difference N(x,y,z) = [ (f(x+1)-f(x-1))/2, (f(y+1)-f(y-1))/2, (f(z+1)-f(z-1))/2 ] Y+1 z+1 x-1, y-1, z-1 X+1

17. 21.05 27.05 24.03 20.05 Classification • Map from numerical values to visual attributes • Color • Transparency • Transfer functions • Color function: c(s) • Opacity function: a(s)

18. 21.05 27.05 24.03 20.05 Classification Order • Pre classification: Classification first, and then filter • Post classification: filter first, then classification 25.3 post pre

19. Optimal model • Assume a denity-emitter model (approximation) • Each data point in the volume can emit and absort light • Light emission – color classification • Light absortion – block light from behind due to non-zero opacity

20. Optical Model • Assuming: x(t) : ray, parameterized by t s(x(t)) : scalar value c(s(x(t)): color; emitted light a(s(x(t)): absortion coefficient

21. t D - a(s(x(t’)))dt’ C = c(s(x(t)) e dt 0 0 D 0 C Ray Integration • Calculate how much light can enter the eye for each ray

22. D 0 C Discrete Ray Integration n i-1 C = SC (1- A ) i i 0 0

23. Compositing (2) Use ‘Front-to-Back’ Compositing formula Front-to-Back compositing: use ‘over’ operator C = initial color ‘over’ C1 C = C ‘over’ C2 C = C ‘over’ C3 … Cout = Cin + C(x)*(1- ain); aout = ain + a(x) *(1-ain) c1 c2 c3

24. Compositing Or Back-to-Front (alpha blending) Back-to-Front compositing: use ‘under’ operator C = C1 ‘under’ initial C = C2 ‘under C C = C3 ‘under C … Cout = Cin * (1-a(x)) + C(x)*a(x) c1 c2 c3

25. Texture Mapping + Textured-mapped polygon 2D image 2D polygon

26. Tex. Mapping for Volume Rendering Consider ray casting … (top view) z y x

27. z y x Texture based volume rendering Use pProxy geometry for sampling • Render every xz slice in the volume as a texture-mapped polygon • The proxy polygon will sample the volume data • Per-fragment RGBA (color and opacity) as classification results • The polygons are blended from back to front

28. Texture based volume rendering

29. y x Changing Viewing Direction What if we change the viewing position? That is okay, we just change the eye position (or rotate the polygons and re-render), Until …

30. y x Changing View Direction (2) Until … You are not going to see anything this way … This is because the view direction now is Parallel to the slice planes What do we do?

31. y x Switch Slicing Planes • What do we do? • Change the orientation of slicing planes • Now the slice polygons are parallel to • YZ plane in the object space

32. y x Some Considerations… (5) When do we need to change the slicing orientation? When the major component of view vector changes from y to -x

33. Some Considerations… (6) Major component of view vector? Given the view vector (x,y,z) -> get the maximal component If x: then the slicing planes are parallel to yz plane If y: then the slicing planes are parallel to xz plane If z: then the slicing planes are parallel to xy plane -> This is called (object-space) axis-aligned method.

34. z y x Three copies of data needed • We need to reorganize the input textures for diff. View directions. • Reorganize the textures on the fly is too time consuming. We want to prepare the texture sets beforehand xz slices yz slices xy slices

35. Texture based volume rendering Algorithm: (using 2D texture mapping hardware) Turn off the depth test; Enable blending For (each slice from back to front) { - Load the 2D slice of data into texture memory - Create a polygon corresponding to the slice - Assign texture coordinates to four corners of the polygon - Render and blend the polygon (use OpenGL alpha blending) to the frame buffer }

36. Problem (1) • Non-even sampling rate d d’ d’’ d’’ > d’ > d Sampling artifact will become visible

37. y x Problem (2) Object-space axis-alighed method can create artifact: Popping Effect There is a sudden change of slicing direction when the view vector transits from one major direction to another. The change in the image intensity can be quite visible

38. d’’ d d’ Solution (1) • Insert intermediate slides to maintain the sampling rate

39. Solution (2) Use Image-space axis-aligned slicing plane: the slicing planes are always parallel to the view plane

40. 3D Texture Based Volume Rendering

41. Image-Space Axis-Aligned Arbitrary slicing through the volume and texture mapping capabilities are needed - Arbitrary slicing: this can be computed using software in real time This is basically polygon-volume clipping

42. Image-Space Axis-Aligned (2) Texture mapping to the arbitrary slices This requires 3D Solid texture mapping Input texture: A bunch of slices (volume) Depending on the position of the polygon, appropriate textures are mapped to the polygon.

43. (r2,s2,t2) (r3,s3,t3) (r1,s1,t1) (r0,s0,t0) 3D Texture Mapping Now the input texture space is 3D Texture coordinates (r,s) -> (r,s,t) (0,1,1) (1,1,1) (0,1,0) (1,1,0) (1,0,0) (0,0,0)

44. Pros and Cons • 2D textured object-aligned slices + Very high performance + High availability - High memory requirement - Bi-linear interpolation - inconsistent sampling rates - popping artifacts

45. Pros and Cons • 3D textured view-aligned slices • + Higher quality • + No popping effect • Need to compute the slicing planes for • every view angle • Limited availability