Monte Carlo Volume Rendering

Transcription

1 Monte Carlo Volume Rendering Balázs Csébfalvi László Szirmay-Kalos Department of Control Engineering and Information Technology Technical University of Budapest (a) 1M samples. (b) 4M samples. (c) 16M samples. Figure 1: Perspective quasi-monte Carlo volume rendering of an engine block using progressive refinement. Abstract In this paper a novel volume-rendering technique based on Monte Carlo integration is presented. As a result of a preprocessing, a point cloud of random samples is generated using a normalized continuous reconstruction of the volume as a probability density function. This point cloud is projected onto the image plane, and to each pixel an intensity value is assigned which is proportional to the number of samples projected onto the corresponding pixel area. In such a way a simulated X-ray image of the volume can be obtained. Theoretically, for a fixed image resolution, there exists an M number of samples such that the average standard deviation of the estimated pixel intensities is under the level of quantization error regardless of the number of voxels. Therefore Monte Carlo Volume Rendering (MCVR) is mainly proposed to efficiently visualize large volume data sets. Furthermore, network applications are also supported, since the trade-off between image quality and interactivity can be adapted to the bandwidth of the client/server connection by using progressive refinement. CR Categories: G.3 [Probability and Statistics]: Probabilistic Algorithms; I.3.3 [Computer Graphics]: Picture/Image Generation Display Algorithms; I.3.7 [Computer Graphics]: Three-dimensional Graphics and Realism Keywords: X-ray volume rendering, Monte Carlo integration, importance sampling, progressive refinement cseb@iit.bme.hu szirmay@iit.bme.hu 1 Introduction Due to the dynamic development of modern 3D scanning technologies, like CT or MRI, the size of the acquired data drastically increases. Therefore efficient and meaningful visualization of large data sets is still one of the most important problems in volume rendering research. In a high resolution volume, one single lowopacity voxel, like a drop in the bucket, has a minimal visual contribution. The question is, whether it is really necessary to process every single voxel in the data to compute high precision pixel values, which are finally quantized anyway. In this paper, an alternative solution is searched for, where instead of a regular resampling an importance-sampling strategy is followed in order to explore the relevant information contained in the data. Exploitation of coherence: Applying the classical volume rendering methods, like ray casting [Levoy 1988; Drebin et al. 1988], or splatting [Westover 199], a volume of size N 3 can be rendered in O(N 3 ) time, since all the voxels have to be traversed. Many acceleration techniques exploit the data coherence by efficiently skipping the empty regions along the viewing rays [Danskin and Hanrahan 1992; Lacroute and Levoy 1994; Cohen and Sheffer 1994]. However, this approach is data dependent and does not improve the worst case time complexity. From practical point of view, interactive rendering of large data sets can be ensured by applying progressive refinement, which is usually based on a hierarchical or multi-resolution decomposition of the volume [Levoy 199; Laur and Hanrahan 1991]. According to this approach, the lower resolution representation of the volume is interactively rotated and whenever the viewing angle is fixed, higher resolution representations are rendered progressively refining the image. Improved time complexity: Another research direction aims at a lower time complexity exploiting a simplified visualization model rather than relying on the data coherence. For example, based on the Fourier projection-slice theorem, a simulated X-ray image of a volume of size N 3 can be rendered in O(N 2 logn) time [Malzbender 1993]. Although the extended version of Fourier Volume Rendering (FVR) supports also shading and depth cueing [Totsuka and Levoy 1993], the compositing is limited to a simple intensity integration. Using FVR for rendering large data sets, it might also be a problem that its memory complexity is O(N 3 ). Therefore, if the

2 Fourier transform of the volume does not fit into the main memory, the inverse transform of a slice with an arbitrary orientation might not be calculated efficiently enough to achieve interactive frame rates. In order to allow progressive refinement in frequency domain rendering, FVR was successfully combined with the wavelet transform [Gross et al. 1997]. This approach benefits from the fact that the Fourier transform of the wavelets and scaling functions can be computed analytically. Fourier Wavelet Volume Rendering (FWVR) [Westenberg and Roerdink 2] is another combined method, which incorporates the advantageous properties of Wavelet Splatting (WS) [Lippert and Gross 1995] and frequency domain rendering. WS was proposed to extend the splatting method by using the wavelets as reconstruction filters. Due to the hierarchical wavelet transform, the data can be visualized by WS at different levels of detail. Similarly to the original splatting method, the time complexity of WS is O(N 3 ). In contrast, FWVR inherits the O(N 2 logn) time complexity of FVR and allows a quick progressive refinement by directly computing the wavelet decomposition of the rendered image. Frequency domain techniques, however, are limited to parallel projection and X-ray like compositing. Hardware acceleration: Although the time complexity of brute-force volume-rendering methods is O(N 3 ), their hardware supported implementation can significantly reduce the constants in the O notation. One possibility is to exploit the 3D texture mapping capability of the conventional graphics hardware [Cabral et al. 1994; Westermann and Ertl 1998]. The main drawback of this technique is that large volumes (more than voxels) currently cannot be loaded into the limited texture memory. Recently, a hierarchical wavelet decomposition of the volume was proposed, where only the levels of detail necessary for display are decompressed and sent to the texturing hardware [Guthe et al. 22]. However, it might happen that the hierarchical representation does not fit even into the main memory, so the performance is drastically reduced because of inefficient swapping. Similar problems arise when the special-purpose VolumePro board [Pfister et al. 1999] is used to visualize large data sets. Taking the above aspects into account, in this paper the strategy of reducing the time complexity as well as the memory complexity is followed. Therefore, similarly to FVR, a simplified optical model is applied. In Section 2 it is explained, how to calculate pixel intensities according to this simplified model by using Monte Carlo sampling. Applying this integration technique, in Section 3 a novel point-based X-ray volume-rendering algorithm is presented. Previously point-based techniques were proposed for surface rendering [Wand et al. 21; Grossman and Dally 1998], volume rendering [Wilson et al. 22; Zwicker et al. 21], non-photorealistic illustration [Lu et al. 22; Secord et al. 22], and volume previewing [Kreylos et al. 2; Saito 1994], but according to our knowledge, Monte Carlo point sampling for X-ray like volume visualization has not been published before. In Sections 4 and 5, the applied quantization method, and the extension to depth cueing and shading are discussed. In Section 6 the deterministic version of the proposed method is introduced. In Sections 7 and 8 the Monte Carlo and quasi-monte Carlo volume-rendering methods are evaluated and compared to previous techniques. Finally, in Section 9 the contribution of this paper is summarized. 2 Monte Carlo Volume Rendering Assume that the input volume is available as a finite number of density samples f (x i, j,k ) located at regular grid points. The convolution of this discrete representation with an appropriate reconstruction kernel h(x) results in a continuous 3D density function: f (x) = f (x i, j,k ) h(x x i, j,k ). (1) i, j,k In classical X-ray volume rendering, a viewing ray is cast through the center of each pixel and the line integral of f (x) is evaluated along the given ray. According to our approach, a pixel intensity I i, j is calculated as a volumetric integral of f (x) over a pyramidal domain V i, j which is projected onto the given pixel (see Figure 2). The calculation of such a volumetric integral can be interpreted as an evaluation of infinitely many rays piercing through the rectangular pixel area. j I i, j image plane i volume V Figure 2: Calculation of a pixel intensity as a volumetric integral over the corresponding pyramidal domain. Applying the Monte Carlo method [Sobol 1994], a volumetric integral I = g(x)dx (2) is formulated as an expected value computation: [ ] g(x) g(x) I = p(x) p(x)dx = E, (3) p(x) where p(x) is a probability density function of samples x. Taking a large number of x k samples obtained with density p(x), the expected value is estimated by the following average: [ ] g(x) I = E 1 M g(x p(x) M k ) k=1 p(x k ). (4) The ideal probability density function is proportional to the integrand, and makes the variance of the estimation zero. The computation of this ideal density, however, would require integral I, thus it is not a feasible alternative. Therefore, in a usual application of Monte Carlo integration, the importance-sampling probability density only mimics the integrand, and is not exactly proportional to it. However, there is a class of problems where the application of the ideal sampling probability makes sense. Suppose that the integrals of a function need to be computed over many subdomains and the integral is known over the entire domain, that is the union of these subdomains. Thus we are able to construct an ideal sampling probability for the entire domain. If this probability density is used for the integrals in the subdomains, the error caused by the variation of the function can be eliminated, only the variation of the subdomain integrals remains. Using this scenario for volume rendering, a pixel intensity I i, j is calculated as follows: [ ] f (x)vi, j (x) I i, j = f (x)dx = f (x)v i, j (x)dx = E, (5) V i, j V p(x) V i, j

3 where the visibility function v i, j (x) is defined as: v i, j (x) = { 1 if x Vi, j otherwise. The visibility function v i, j (x) takes only those x samples into account which fall into the domain V i, j. This function is introduced in order to formulate integral I i, j over the entire volume V rather than over the domain V i, j. Since we want to use the same set of random samples x k to generate different views of the volume, the probability density function p(x) is defined proportional only to the view-independent term of the integrand, that is the reconstructed density function itself: (6) f (x) p(x) =. (7) V f (x)dx The probability that a random sample x k falls into the domain V i, j is expressed as: p i, j = p(x)dx. V i, j (8) Due to the importance sampling, Equation 5 is simplified as follows: [ ] f (x)vi, j (x) I i, j = E = f (x)dx E[v i, j (x)]. (9) p(x) V When the integrals are mapped onto pixel intensities, their relative differences are important and not their absolute values. Therefore a normalized intensity I i, j is assigned to the corresponding pixel rather than the absolute value of integral I i, j : I i, j = I i, j V f (x)dx = p i, j = E[v i, j (x)]. (1) Taking M number of x k random point samples according to the probability density function p(x), the expected value E[v i, j (x)] can be estimated by an average calculation: E[v i, j (x)] 1 M M v i, j (x k ) = M i, j k=1 M, (11) where M i, j is the number of those point samples which fall into the domain V i, j. In fact, the random variable M i, j takes its value according to a binomial distribution: ( ) M P[M i, j ] = p M i, j M i, j (1 p i, j ) M M i, j. (12) i, j Therefore the variance Var[M i, j /M] of the random variable M i, j /M is derived as follows: [ ] Mi, j Var = Var[M i, j] M M 2 = Mp i, j(1 p i, j ) M 2 = p i, j(1 p i, j ). (13) M Thus, taking M random point samples, the random variable M i, j /M gives an unbiased estimation of the normalized pixel intensity I i, j with standard deviation O(M 1/2 ). 3 X-Ray Volume Rendering Applying the results presented in the previous section, an X-ray like volume-rendering algorithm can be implemented in a very simple way. First the input volume is preprocessed and a point cloud of random samples is generated according to the probability density function p(x). Afterwards the point samples are projected onto the image plane. The normalized intensity of each pixel is estimated as the number of samples projected onto the given pixel divided by the number of all the samples in the point cloud. In order to generate random point samples according to the probability density function p(x), a uniform random distribution has to be transformed into the required distribution [Sobol 1994]. Let us denote the ith voxel in the sequence of voxels represented by the input file by v i. Assume that r 1, r 2,..., r M is a sequence of uniformly distributed and independent random numbers in the interval [, 1]. Each random sample x k in the point cloud is generated in two steps from the corresponding random number r k in the following way. First a voxel location v i(k) is randomly selected if r k > F(v i 1 ) and r k F(v i ) (see Figure 3), where the distribution function F(v i ) is defined as: 1 r k F(v i ) = 1 n f (v n ) i i f (v j ). (14) j=1 F( v i ) F( v i-1 ) Figure 3: Random selection of the ith voxel. In the second step, the normalized reconstruction kernel h (x) = h(x)/ h(y)dy (see Equation 1) is used as a local probability density function for generating a random translation vector t k, which is added to the voxel location v i(k) selected in the first step (such an irregular sampling is similar to interleaved sampling [Keller and Heidrich 1998], which was proposed to reduce inter-pixel aliasing). Thus the kth random sample in the point cloud is calculated as x k = v i(k) + t k. The restrictions for the reconstruction kernel h(x) are the following: 1. h(x) is separable as a direct product of 1D kernels, 2. h(x) is non-negative over its domain, 3. the integral of h(x) exists over all intervals. In practice, the number of samples in the point cloud is a compromise between image quality and rendering speed, therefore it can be adapted to the available hardware resources. On the one hand, the point cloud has to fit into the main memory to avoid swapping during the rendering. On the other hand, the rendering speed depends on the performance of the processor. The trade-off between image quality and speed, however, can be controlled by progressive refinement (see Figure 1). A subset of the point samples can be interactively rotated, and after having the appropriate viewing direction fixed, the rest of the samples are projected onto the image plane progressively refining the estimation. A naive implementation of the preprocessing would require a random access to the voxels, and it might cause an inefficient swapping if the entire volume does not fit into the main memory. Therefore it is worthwhile to sort random sequence r 1, r 2,..., r M in an ascendant order beforehand, since in this case the voxels v i can be

4 accessed in the order as they are stored in the data set. Thus the volume can be processed slice by slice without loading it entirely into the main memory. However, the random point samples have to be projected onto the image plane in an order which corresponds to the generation order of random numbers r i because of the progressive refinement. Therefore, after the preprocessing, the point samples are written into an output file in this original order. Note that, if the input volume is anisotropic, it can be preprocessed as it was an isotropic one, and afterwards the generated point samples can be scaled according to the real sampling distances. 4 Quantization A simulated X-ray image of the volume is rendered by quantizing the estimated normalized intensities onto L gray levels provided by the available display device. For each pixel, the quotient M i, j /M is mapped onto a quantized pixel intensity Q i, j using the following formula: { L 1 if L WH B Mi, Q i, j = j /M L (15) L WH B M i, j /M otherwise, where W and H are the width and height of the image in pixels respectively, while B is the average luminance taken from the interval [, 1]. Such a mapping of the estimated normalized intensities maintains the average pixel brightness in images of different resolutions generated from the same number of random samples. It is easy to see that the average pixel variance of the generated image is maximum if the projection of the volume is uniformly distributed. In this worst case p i, j = 1/WH, therefore the variance Var[M i, j /M] is derived from Equation 13 as follows: Var [ ] Mi, j = 1 ( 1 M M WH 1 ) W 2 H 2. (16) The probabilistic error of the image is characterized by the average standard deviation of the quantized pixel intensities Q i, j, which can be reduced under the level of quantization error if the following condition is fulfilled: M > ( 1 WH 1 W 2 H 2 ) W 2 H 2 B 2 L 2 WHB 2 L 2. (17) For example, assuming an image resolution of , 256 quantization levels (L = 256), and a brightness factor B = 1/16, a simulated X-ray image of an arbitrarily large volume can be generated from 16M random samples keeping the average standard deviation of pixel values under the level of quantization error. From practical point of view, an appropriate image quality can be ensured by taking even fewer samples, since a human eye can distinguish less then 256 gray levels. The number of samples necessary for a certain accuracy depends on the square of the brightness factor B. On the other hand, setting a higher value of B, more pixels will burn out (intensity is quantized to L 1) making their variances zero. Therefore these pixels will not contribute to the overall image error. 5 Depth Cueing and Shading The main drawback of the classical X-ray like volume rendering is the low contrast of the generated images and the lack of depth information. The spatial impression can be improved by depth cueing and shading. For shading computations surface normals are necessary, therefore gradients at grid points have to be estimated by using, for example, the method of central differences. Note that the gradients of random samples can be calculated during the preprocessing by trilinearly interpolating the estimated gradients at the eight closest grid points. The interpolated and normalized gradients, that are considered to be surface normals, are stored together with the location vectors in an array representing a point cloud. In the rendering process, each density sample f (x k ) is multiplied by a depth-cueing factor d(x k ) and a shading factor s(x k ) calculated according to normal n k and the lighting conditions. In this case, pixel intensity I i, j is estimated in the following way: I i, j 1 M M f (x k ) k=1 p(x k ) v i, j(x k ) s(x k ) d(x k ) (18) = f (x)dx 1 M V M v i, j (x k ) s(x k ) d(x k ). k=1 MCVR also supports surface enhancement, where each sample intensity is weighted by the corresponding interpolated gradient magnitude rather than by the interpolated density value. In this case, the probability density function p(x) is calculated by normalizing the reconstructed function of gradient magnitudes instead of the reconstructed density function. Due to this modification, samples are taken with a higher probability from the vicinity of well defined isosurfaces rather than from homogeneous regions. 6 Quasi-Monte Carlo Integration The convergence can be slightly accelerated by applying quasi- Monte Carlo (QMC) [Keller 1998] integration, which is formally equivalent to Monte Carlo (MC) integration but it operates with deterministic sequences instead of random numbers. However, its theoretical interpretation is different since terms like probability distribution cannot be used. In order to generate a point cloud, a 3D low-discrepancy Halton sequence [Keller 1996] defined in the unit cube is transformed into the required distribution. The kth vector in this 3D Halton sequence is calculated as h k = [Hk 5,H3 k,h2 k ], where Hb k denotes the kth number in a 1D Halton sequence of base b. Each sample x k = [x k,y k,z k ] in the point cloud is generated from the corresponding Halton point h k according to the following equations: where Hk 2 zk = p(x, y, z)dxdydz, (19) Hk 3 yk = p(x,y z k )dxdy, Hk 5 xk = p(x y k,z k )dx, p(x,y,z) = p(x,y z k ) = f ([x,y,z]) f ([x,y,z])dxdydz, p(x,y,z k ) p(x,y,zk )dxdy, p(x y k,z k ) = p(x,y k,z k ) p(x,yk,z k )dx. In fact, these equations define a transformation T (x) which maps a sample location x in volume V onto a point h in the unit cube. Using this mapping for variable transformation, a pixel intensity I i, j can be formulated as follows: I i, j = c i, j (x)dx = c i, j (T 1 (h)) V [,1] 3 T 1 (h) h dh, (2)

5 where c i, j (x) = f (x) v i, j (x) s(x) d(x), and T 1 (h) h is the Jacobian determinant of the inverse transformation [Keller 1996; Szirmay-Kalos et al. 1998]. Applying the quasi-monte Carlo approach, integral 2 is approximated as follows [Keller 1998; Niederreiter 1992]: I i, j 1 M M c i, j (T 1 (h k )) T 1 (h k ) k=1 h. (21) According to the Koksma-Hlawka inequality [Niederreiter 1992], the error of such an approximation is upperbounded by the product of the Hardy-Krause variation of the integrand and the discrepancy of the point set (which is O(log 3 M/M) for the threedimensional Halton series). Unfortunately, the integrands contain discontinuities at the domain boundaries, that are not necessarily parallel to the coordinate axes, thus the variation is infinite. The generalization of the Koksma-Hlawka inequality for such functions [Szirmay-Kalos and Purgathofer 1999; Press et al. 1992] shows that in such cases the convergence rate is O(M 2/3 ). The quasi-monte Carlo preprocessing, similarly to MCVR, can also be performed without loading the entire data set into the main memory. If the 3D Halton points h k are sorted according to their z-coordinate, the corresponding samples x k can be generated processing the input volume slice by slice. Assuming that M = 2 m 1, where m is a positive integer, the sorted sequence of z-components Hk 2 is: 1/2m, 2/2 m,..., (2 m 1)/2 m. Due to this property of the Halton sequence of base 2, there is no need to use any conventional sorting algorithm. The corresponding y and x components can be easily generated from the z-component by using an inverse Halton generator for calculating the index k from Hk 2. Because of the progressive refinement, the x k samples are written into an output file in an order which corresponds to the generation order of points h k. 7 Implementation (Q)MCVR was implemented in C++ and tested on a 2GHz AMD Athlon XP 26 PC with 1GB of RAM. The test CT data sets containing a lobster, an engine block, and an Xmastree, represent volumes of small ( ), medium ( ), and large size ( ) respectively. Figure 4 shows the RMS errors of the images generated by using MCVR (a, c) and QMCVR (b, d) for X-ray (a, b) and shaded (c, d) rendering. The normalized intensities were mapped onto the interval [,256) and the RMS errors were calculated before the quantization. The horizontal axis represents the M number of samples on a logarithmic scale. The image resolution was for all the three test volumes, and the accurate solutions were calculated for this fixed image resolution by analytically integrating the translated and scaled copies of the reconstruction kernel, taking only those regions into account which are visible from the given pixel. The absolute error levels are mainly influenced by the brightness factors, which were B =.125 for X-ray rendering and B =.5 for shaded rendering. Figure 5 shows the X-ray (a - f) and shaded images (g - l) generated by QM- CVR using 1M (a - c, g - i) and 16M (d - f, j - l) samples. In order to demonstrate that our method does not necessarily require an expensive graphics card to achieve high performance, we implemented it purely in software without exploiting the 3D hardware acceleration. Frame rates of X-ray rendering and shaded rendering are shown in Table 1. In case of shaded rendering the Lambertian model was used with three light sources of different colors (red, green, and blue). In our future work, we intend to implement (Q)MCVR more efficiently using the latest generation graphics cards, which support additive alpha blending in 128-bit floating-point mode. In lowerprecision modes accumulated pixel values would easily overflow. number of samples 1M 4M 16M X-ray rendering Hz 5.32 Hz 1.39 Hz shaded rendering 9.17 Hz 2.67 Hz.67 Hz Table 1: Frame rates of X-ray and shaded rendering. data set lobster engine xmastree X-ray MCVR 14.5 sec 14.7 sec 3.9 sec X-ray QMCVR 21 sec 168 sec 169 sec shaded MCVR 24.9 sec 26.4 sec 194 sec shaded QMCVR 217 sec 188 sec 333 sec Table 2: MC and QMC preprocessing times for 16M samples. If high-precision alpha blending is supported, the GPU can execute all the tasks necessary for rendering, like projection, depth cueing, shading, and accumulation based on additive alpha blending. Furthermore, the performance can be optimized by loading the point cloud (or a subset of the point cloud), as a static vertex array, into the local video memory for a more efficient vertex processing. Although, taking the same number of sample points, QMCVR provides more accurate results than MCVR does, its preprocessing cost is significantly higher due to the more complicated generation of sample points. In a practical application, a hybrid approach can be applied as a trade-off between MC and QMC preprocessing. For example, using a deterministic Halton sequence to generate quasi random numbers (r k = Hk 2 ) for the cumulative technique presented in Section 3, almost the same image quality can be achieved as using QMC sampling. Furthermore such a hybrid preprocessing is even faster than a pure MC sample generation, since there is no need to sort the samples (see Section 6). Table 2 shows the preprocessing times for MCVR and QMCVR generating 16M sample points. In both cases a direct product of a tent filter was used as a reconstruction kernel h(x), which is equivalent to a trilinear interpolation. When samples are produced for X-ray rendering only the location vectors have to be calculated, while for shaded rendering at each sample point an additional gradient has to be interpolated. 8 Comparison to Previous Methods (Q)MCVR is based on volumetric rather than line integration, therefore a quantitative comparison to previous methods does not make sense. Considering the advantageous and disadvantageous properties, (Q)MCVR is compared to FVR and hardware accelerated 3D texture mapping (TM) in Table 3. Among the previous techniques, FVR is considered to be theoretically the fastest volume-rendering method due to its O(N 2 logn) time complexity, while from the practical point of view, TM is one of the most popular hardware accelerated techniques, which provides interactive frame rates for volumes of medium size (256 3 ). According to Section 4, the time complexity as well as the memory complexity of MCVR is proportional to the number of pixels (O(WH)) and does not depend on the number of voxels. However, projecting a volume of size N 3 onto an image of resolution N 2 seems to be a good base for fair comparison of time and memory costs. In this sense, the time complexity as well as the memory complexity of MCVR is O(N 2 ) (after a preprocessing of O(N 3 ) time complexity), where it is assumed that the image resolution is fixed (W = H = N) and zooming is not allowed. The same is valid for QMCVR since its asymptotic error bound is lower than that of MCVR. Although FVR and TM have time complexities O(N 2 logn) and O(N 3 ) respectively, due to the constants in the O notation, (Q)MCVR provides lower frame rates when small data sets need to be rendered.

6 RMS error lobster engine xmastree RMS error lobster engine xmastree M 2M 4M 8M 16M 1M 2M 4M 8M 16M number of sample points number of sample points (a) (b) RMS error 15 1 lobster engine xmastree RMS error 15 1 lobster engine xmastree 5 5 1M 2M 4M 8M 16M number of sample points 1M 2M 4M 8M 16M number of sample points (c) (d) Figure 4: RMS errors of X-ray (a, b) and shaded (c, d) images generated by Monte Carlo (a, c) and quasi-monte Carlo (b, d) volume rendering. FVR TM (Q)MCVR time complexity O(N 2 logn) O(N 3 ) O(N 2 ) memory complexity O(N 3 ) O(N 3 ) O(N 2 ) accuracy depends on the slicing discrete approximation QMC: O(M 2/3 ), MC: O(M 1/2 ) compositing intensity integration alpha-blending intensity integration shading linear or approximate models Phong shading no restrictions projection parallel parallel or perspective parallel or perspective Table 3: Comparison of (Q)MCVR to Fourier volume rendering (FVR) and texture mapping (TM). However, in case of large volume data sets, the bottleneck of previous techniques is mainly their memory cost. For instance, FVR assumes that the frequency domain representation of the volume is stored in the main memory, therefore slicing can be performed efficiently enough to achieve interactive frame rates. Using 3D texture mapping, if the entire volume cannot be loaded into the limited 3D texture memory, it has to be decomposed into blocks, which are then swapped. In this case, it might also be a problem if the volume does not fit even into the main memory, so the performance is significantly reduced. In contrast, (Q)MCVR can be adapted to the available hardware resources, since the number of samples which guarantees a certain accuracy does not depend on the size of the input volume. If there is not enough memory to load the point cloud or the processor is not fast enough to achieve high frame rates, a lower-quality approximation can still be rendered interactively by projecting only an appropriate subset of the samples. Furthermore, network applications based on progressive refinement are also supported by (Q)MCVR. Considering the image quality, it is difficult to compare (Q)MCVR to previous methods, since the visualization models they are based on are different. Theoretically FVR provides accurate line integrals along the viewing rays. In practice, however, the image quality strongly depends on the resampling filter applied for the slicing, which influences also the performance. Using TM, the discrete approximation of the volume rendering integral is calculated by resampling the volume along each viewing ray at evenly located sample points. Nevertheless, the image quality can be improved by using pre-integrated volume rendering [Engel et al. 21]. Applying MCVR a probabilistic O(M 1/2 ) error bound can be ensured, while QMCVR has O(M 2/3 ) error bound. The major drawback of (Q)MCVR is that compositing is limited to intensity integration, like in case of FVR. On the other hand, FVR is restricted to linear (like hemispherical illumination) or approximate shading models [Entezari et al. 22], while using (Q)MCVR there is no such a restriction. Furthermore FVR is limited to parallel projection, while (Q)MCVR supports also perspective projection. One further drawback of (Q)MCVR is, that it is designed for external views. Therefore, similarly to some previous methods, like FVR or the shear-warp algorithm [Lacroute and Levoy 1994], volume navigation and high-quality zooming are not supported.

7 (a) (b) (c) (d) (e) (f) (g) (h) (i) (j) (k) (l) Figure 5: X-ray (a - f) and shaded (g - l) images of the test data sets generated by quasi-monte Carlo volume rendering using 1M (a, b, c, g, h, i) and 16M (d, e, f, j, k, l) samples.

8 9 Conclusion and Future Work In this paper novel volume-rendering methods based on Monte Carlo and quasi-monte Carlo integration have been presented. These techniques are mainly proposed to interactively visualize large data sets, which do not necessarily fit into the main memory. It has been shown, that the time complexity as well as the memory complexity of (Q)MCVR is proportional to the number of pixels and does not depend on the number of voxels. Assuming a fixed image resolution, there exists an M number of samples such that the average error of the estimated pixel intensities is under the level of quantization error regardless of the size and the content of the data. In this sense, accurate X-ray like images of arbitrarily large volumes can be produced in constant time after the preprocessing. Moreover, our method supports depth cueing, shading, and progressive refinement. Its main drawback, however, is that compositing is limited to intensity integration. Therefore, in our future work, we will investigate, how to introduce occlusion into (Q)MCVR. Acknowledgements This work has been supported by OTKA 42735, IKTA 159/22 and the Slovenian-Hungarian Action Fund. The Xmastree data set was provided by the Institute of Computer Graphics and Algorithms at the Vienna University of Technology as a large benchmark scene for volume-rendering algorithms ( References CABRAL, B., CAM, N., AND FORAN, J Accelerated volume rendering and tomographic reconstruction using texture mapping hardware. In Proceedings of IEEE Symposium on Volume Visualization, COHEN, D., AND SHEFFER, Z Proximity clouds - an acceleration technique for 3D grid traversal. The Visual Computer, Vol.11, No.1, DANSKIN, J., AND HANRAHAN, P Fast algorithms for volume ray tracing. In Proceedings of Workshop on Volume Visualization, DREBIN, R., CARPENTER, L., AND HANRAHAN, P Volume rendering. Computer Graphics (Proceedings of SIGGRAPH 88), ENGEL, K., KRAUS, M., AND ERTL, T. 21. High-quality pre-integrated volume rendering using hardware-accelerated pixel shading. In Proceedings of EUROGRAPHICS/SIGGRAPH Workshop on Graphics Hardware, ENTEZARI, A., SCOGGINS, R., MÖLLER, T., AND MACHIRAJU, R. 22. Shading for Fourier volume rendering. In Proceedings of IEEE Symposium on Volume Visualization and Graphics, GROSS, M. H., LIPPERT, L., DITTRICH, R., AND HÄRING, S Two methods for wavelet-based volume rendering. Computers and Graphics, Vol.21, No.2, GROSSMAN, J. P., AND DALLY, W. J Point sample rendering. In Proceedings of EUROGRAPHICS Workshop on Rendering, GUTHE, S., WAND, M., GONSER, J., AND STRASSER, W. 22. Interactive rendering of large volume data sets. In Proceedings of IEEE Visualization 22, KELLER, A., AND HEIDRICH, W Interleaved sampling. In Proceedings of EUROGRAPHICS Workshop on Rendering, KELLER, A The fast calculation of form factors using low discrepancy sequences. In Proceedings of Spring Conference on Computer Graphics, KELLER, A Quasi Monte Carlo Methods for Photorealistic Image Synthesis. Ph.D. thesis, Shaker Verlag Aachen. KREYLOS, O., MA, K.-L., AND HAMANN, B. 2. A multi-resolution interactive previewer for volumetric data on arbitrary meshes. In Proceedings of Workshop on Computer Graphics and Virtual Reality 2, International Computer Symposium. LACROUTE, P., AND LEVOY, M Fast volume rendering using a shear-warp factorization of the viewing transformation. Computer Graphics (Proceedings of SIGGRAPH 94), LAUR, D., AND HANRAHAN, P Hierarchical splatting: A progressive refinement algorithm for volume rendering. Computer Graphics (Proceedings of SIGGRAPH 91), LEVOY, M Display of surfaces from volume data. IEEE Computer Graphics and Applications, Vol.8, No.3, LEVOY, M Volume rendering by adaptive refinement. The Visual Computer, Vol.6, No.1, 2 7. LIPPERT, L., AND GROSS, M. H Fast wavelet based volume rendering by accumulation of transparent texture maps. Computer Graphics Forum (Proceedings of EUROGRAPHICS 95), LU, A., MORRIS, C., EBERT, D., RHEINGANS, P., AND HANSEN, C. 22. Non-photorealistic volume rendering using stippling techniques. In Proceedings of IEEE Visualization 22, MALZBENDER, T Fourier volume rendering. ACM Transactions on Graphics, Vol.12, No.3, NIEDERREITER, H Random number generation and quasi-monte Carlo methods. SIAM, Pennsilvania. PFISTER, H., HARDENBERGH, J., KNITTEL, J., LAUER, H., AND SEILER, L The VolumePro real-time ray-casting system. Computer Graphics (Proceedings of SIGGRAPH 99), PRESS, W., FLANNERY, B., TEUKOLSKY, S., AND VETTERLING, W Numerical Recipes in C (Second Edition). Cambridge University Press. SAITO, T Real-time previewing for volume visualization. In Proceedings of IEEE Symposium on Volume Visualization, SECORD, A., HEIDRICH, W., AND STREIT, L. M. 22. Fast primitive distribution for illustration. In Proceedings of EUROGRAPHICS Workshop on Rendering, SOBOL, I A Primer for the Monte Carlo Method. CRC Press. SZIRMAY-KALOS, L., AND PURGATHOFER, W Analysis of the quasi-monte Carlo integration of the rendering equation. In Proceedings of Winter School of Computer Graphics, SZIRMAY-KALOS, L., CSÉBFALVI, B., AND PURGATHOFER, W Importance driven quasi-random walk solution of the rendering equation. In Proceedings of Winter School of Computer Graphics, TOTSUKA, T., AND LEVOY, M Frequency domain volume rendering. Computer Graphics (Proceedings of SIGGRAPH 93), WAND, M., FISCHER, M., PETER, I., AUF DER HEIDE, F. M., W., AND STRASSER, W. 21. The randomized z-buffer algorithm: Interactive rendering of highly complex scenes. Computer Graphics (Proceedings of SIGGRAPH 21), WESTENBERG, M. A., AND ROERDINK, J. B. T. M. 2. Frequency domain volume rendering by the wavelet X-ray transform. IEEE Transactions on Image Processing, Vol.9, No.7, WESTERMANN, R., AND ERTL, T Efficiently using graphics hardware in volume rendering applications. Computer Graphics (Proceedings of SIGGRAPH 98), WESTOVER, L Footprint evaluation for volume rendering. Computer Graphics (Proceedings of SIGGRAPH 9), WILSON, B., MA, K.-L., QIANG, J., AND RYNE, R. 22. Interactive visualization of particle beams for accelerator design. P.M.A. Sloot et al. (Eds.) ICCS 22, LNCS 2331, ZWICKER, M., PFISTER, H., VAN BAAR, J., AND GROSS, M. 21. EWA volume splatting. In Proceedings of IEEE Visualization 21,