A hardware based implementation of the Multipath method

Transcription

1 A hardware based implementation of the Multipath method Roel Martínez*, László Szirmay-Kalos, Mateu Sbert* *Institut d'informática i Aplicacions, Universitat de Girona {roel,mateu}@ima.udg.es Department of Control Engineering and Information Technology, Technical University of Budapest szirmay@iit.bme.hu Abstract This paper presents a depth buffer hardware implementation of the multipath algorithm for radiosity. The implementation makes use of bundles of parallel lines implemented with the OpenGL's depth buffer. The new algorithm is compared with the earlier painter algorithm implementation and we conclude that the proposed technique can result in half a magnitude of speed increase, and can render the indirect illumination in moderately complex scenes in a few seconds. keywords: Radiosity, depth buffer, OpenGL, Monte Carlo. 1. Introduction Global illumination algorithms compute the single reflection of the light many times to simulate the multiple reflections. To obtain a single reflection at a point, the estimate of the incoming radiance is multiplied by the probability of the reflection and the product is integrated taking into account all the possible incoming directions. Consequently, global illumination is basically a numerical integration problem. Local Monte-Carlo approaches sample the domain of the integration randomly using a probability density p(x), evaluate the integrand f(x) here, and provide the f/p ratio as the primary estimate of the integral. This estimate is accurate if we can find p that precisely mimics f, i.e. it makes f/p as flat as possible. This strategy, which is commonly referred as importance sampling, places more samples where the integrand is large. Since in practice p can be very far from the integrand, the

2 (a) (b) Figure 1. (a) Random walk simulation with global lines. A global line (the thick continuous one) makes two paths advance at once. Considering bi-directionality of the global lines, two other paths will also advance in the reverse direction of the line. (b) Note that the exit point on each patch is random. estimator may have high variance. Thus to get an accurate result many independent primary estimators should be used to compute the secondary estimator as their average. Global Monte-Carlo methods do not rely on the hope to find good sampling density. Instead, they take advantage of the fact that it is usually easy to evaluate function f at a well structured set of sample points x 1,,x n. The emphasis is on that the simultaneous computation of f(x 1 ),, f(x n ) is much cheaper than the individual computation of f(x 1 ),, and f(x n ) by a local method, thus in this way we can have much more samples for the same computational effort. The disadvantage of this technique is that finding a probability density that simultaneously mimics the integrand at many points is very difficult, thus practical methods usually use uniform sampling probability. In this way, global methods are implemented using global uniformly distributed lines, in contraposition to local lines, generated from sampled points in the scene. The multipath algorithm [9],[10] belongs to the family of global lines algorithms which has seen a further developing in [1],[2],[12],[13]. The objective of this paper is to demonstrate that it is possible and worth to implement the multipath method using hardware acceleration techniques, particularly the OpenGL's depth buffer. The rest of the paper is organized as follows. In section 2 we present the multipath method with single lines and also with bundles of lines. In section 3 we introduce the depth buffer hardware implementation. In section 4 we show our results and finally present the conclusions.

3 Figure 2. The global line AB will transport power from patch P1 to P2 and from patch P3 to patch P4. Patches P1 and P4 are on the walls of the interior scene. Considering bi-directionality, the line will also transport power from P2 to P1 and from P4 to P3. 2. Multipath method 2.1 Previous work Global lines were first used in rendering by Buckalew in [3]. In [8] Sbert showed the intimate relationship of global lines to radiosity and used them to develop a full matrix radiosity method. The multipath algorithm for radiosity [9],[10] eliminated the need for computing the form factors explicitly, and was shown in [10] that it could be interpreted as a random walk algorithm. In [9],[10] the multipath was implemented with bundles of parallel rays, but the coherence properties have not been exploited. Meanwhile, Neumann [6] presented independently the transillumination algorithm, that has been further developed by [11], [12] and [13] in order to generalize it also for non-diffuse environments. These methods used the painter algorithm to generate global lines in bundles. 2.2 Multipath algorithm with single lines The multipath algorithm, described in [9],[10] uses segments of global lines to build random walks that mimic classic random walks with infinite path length (see figure 1) The main differences between multipath and a classic (local) random walk approach are the source probability selection, the simultaneous advance of different paths thanks to global lines, and transporting different logical paths in a single geometrical one. The multipath method is only efficient in smoothed scenes, with emittance occupying a larger part of the scene and more or less equilibrated. For this reason a first shot distributing direct illumination before applying the algorithm is necessary (see also [4] and [14]). Multipath algorithm casts a predetermined number of random global lines using, for instance, pairs of random points on an enclosing sphere. Each line will produce an intersection list, and the list is traversed taking into account each successive pair of patches (see figure 2). Each patch (if not emitter) stores two quantities. One records the power accumulated, and the other the unshot power. For every pair of patches along the intersection list, the first patch of the pair will transmit its unsent power to

4 Figure 3. Bundle of parallel lines, where S is the sphere that wraps the scene, B is the bundle of lines, P is the projection plane, orthogonal to S and N is the normal to the projection plane. the second patch of the pair. So the unshot energy of the first patch is reset to zero, and the two quantities at the second patch, the accumulated and the unsent energy, are incremented. In the case of a source a third quantity is also kept, the emitted power per line exiting the source. This power is precomputed in the following way: Given the number of lines to cast, the forecast number of lines passing through any source is found. This can be done with Integral Geometry methods [7]. The division of the total source power by this number of forecast lines gives the predicted power of one line. Then, if the first patch of a pair is a source patch, the power transported to the second patch of the pair will also include this predicted power portion. 2.3 Multipath with bundles of parallel lines In [5] the multipath method has been extended to transfer radiosity with bundles of parallel lines, which takes advantage of the ray-coherence. The bundle of parallel lines is simulated using a general purpose polygon filling algorithm, called the painter algorithm. The bundle of parallel lines is created as follows (see figure 3) First the scene is wrapped in a sphere. Then a random point is selected on the surface of the sphere, and an orthogonal plane to the sphere is obtained. We call this plane the projection plane. The direction of the bundle of parallel lines is defined perpendicular to the plane. The projection plane is associated with XY coordinates and is decomposed to n by m pixels. Every pixel originates a line, and all patches that are projected in the same pixel are used in order to compute the exchange of energy between them, having sorted them according to their z values.

5 Figure 4. The probability that the plane P, orthogonal to Z-axis, crosses between object O1 and the ceiling is given by the distance between the object and the ceiling Zd1 divided by the maximum distance in the scene Zdist. Also, the probability that P crosses between O2 and LS is given by Zd2/Zdist. 3. A new algorithm 3.1 Representative projection Suppose that in the global direction the maximum distance of the patches from the projection plane is between Z1 and Z2. Let us generate a uniformly distributed random number z between Z1 and Z2 and place a clipping plane at z. The clipping plane will be that one which is orthogonal to the global direction and is at distance z from the reference and can be considered as a translated projection plane. Defining a window on the clipping plane to include the projection of all patches, let us run two depth buffer hardware renderings, one with GREATER and the other with LOWER settings, together with the enabling and disabling the two half-spaces on the two sides of the clipping plane. Reading back the images we have a set of mutually visible pixels (patches), which can be used to exchange energy. Note that here a patch exchanges energy only with a given probability. This probability is proportional to their distance in z. Thus for each pair of pixels (that simulates a global line segment) the energy exchange is divided by this probability. 3.2 Probability that a plane crosses between two patches Suppose that in a scene (see figure 4) we generate a global random direction. This direction defines the Z-axis of the scene. In figure 4 the Z-axis is parallel to the scene wall just for the sake of simplicity. The Z coordinates of all scene patches are between zmax and zmin, which are the maximum and minimum Z values of the scene. Let us generate a uniformly distributed random number z between zmax and zmin that defines a random point RP, and a plane P orthogonal to the Z-axis is placed at RP. Now, what is the probability that the plane P crossed between the points z12 and z11? Suppose, for example, that the point z12 is on object O1 and the point z11 is on the ceiling. The probability is the distance between z12 and z11, Zd1,

6 (a) (b) (c) (d) Figure 5. (a) A simple scene with two object and a light source (LS) (b) A random direction RD and a random point RP are selected. In this case, for simplicity, RD is parallel to one of the scene axis. (c) A plane with two opposite normals (P1 and P2) is created incident to RP, and are decomposed into nxn pixels. (d) A projection directions (D1 and D2) are defined. D1 has the same direction than RD and D2 is opposite to D1. divided by the maximum Z distance (zmax-zmin) in the scene, Zdist. The probability that the plane P crossed between the points z22 and z21 is Zd2/Zdist. Note that the OpenGL pipeline scales the Z values to be in [0..1] before writing them into the z- buffer. It means that at the end of the transformation pipeline Zdist=1, thus the calculation of the probabilities needs only one addition. 3.3 Implementation The bundle of parallel lines is obtained as follows: First, a random direction D r is selected. This direction defines the Z-axis. Then a random point P r between the minimum and maximum values of Z is selected (see figure 5(b)). The window plane, i.e. the projection plane, is defined incident to P r and orthogonal to D r (see figure 5 (c)), which will be used two times with two opposite viewing directions. All patches are projected onto the projection plane from the two directions using the OpenGL's depth buffer (see figure 6). Finally, the exchange of power is computed between the corresponding pixels of the two rendering steps (see figure 7). This is summarized in the following algorithm.

7 begin sendbundle Compute a random direction RD (defining the Z-axis) Compute a random point RP between minimum and maximum values of Z Create two opposite projection planes (orthogonal to RD, defined at RP and nxn size) Define the projection directions Clear the projection planes Project allpatches_vector onto projection plane 1 Project allpatches_vector onto projection plane 2 For i=0 to projectionplanewidth do For j=0 to projectionplaneheight do coord1 = i * projectionplanewidth + j index1 = projectionplane1[coord1] coord2 = i*projectionplanewidth+projectionplanewidth-j-1 index2 = projectionplane2[coord2] compute Z distance between allpatches_vector[index1] and allpatches_vector[index2] using the Zvalues in the depthbuffer Exchange power between allpatches_vector[index1] and allpatches_vector[index2] divided by the Z distance endfor endfor end Figure 6. After all patches (see figure 5(a)) are projected onto the projection planes, the result is (a) lower section and (b) upper section of the projected scene, where w is the pixel width of the projection plane. The discretized projection planes are represented by matrices with nxn pixels (n is defined by the user) and they store the closest patch IDs that are projected onto them. The two polygons identified by the IDs in the corresponding positions (for the two projection planes, see figure 7) will exchange power. The exchange power function is similar to the multipath single line implementation, explained in section 2.2. The only difference is that now the power is divided by the probability that a

8 Figure 7. Exchange of energy between two projection planes. plane crosses between two patches. This probability is given by the sum of the two Z values as read out from the z-buffer. 4. Results and discussion We have implemented the presented algorithm in C++ and run the program on an SGI Octane computer with a MIPS R MHZ IP30 processor. A complete rendering consists of the computation of the first-shot, i.e. the determination of the direct illumination, and the multipath step that computes the indirect illumination. The first shot step was implemented with local lines, although a hardware based implementation is also available in [14]. In this step were used 4 million local lines. We evaluate here the performance of the multipath step since the proposed algorithm alters only this phase of the computation. We used two particular test scenes. The big room scene (figure 9) consists of 1130 polygons that have been subdivided into patches. The office scene (figure 11) contains 547 polygons decomposed into patches. The size of the depth buffer matrices is 100x100 pixels for both test scenes. It means that every bundle of parallel lines has 10,000 global lines. The new algorithm could render these scenes in 5.8 and 5.7 seconds respectively, while the program implementing the painter algorithm needed 41 and 37 seconds respectively. This corresponds to a speed up of 7. In figures 8(b) and 10 are plotted the number of bundles vs the time in seconds for the big room and the office scenes, respectively. The performance of the depth buffer implementation is clearly better than the painter implementation. In figure 8(a) we see that the error for a different number of bundles is practically the same, in both depth buffer and painter algorithms, with a very slight advantage, for a small number of bundles, for the painter's implementation. This difference is because the probability that a plane crosses between two patches is very small when the distance between them is small too. For example, in figure 9(a) the table patches near the wall (that is not visible in the image) received almost no energy and in figure 9(b) the same table patches have better illumination results.

9 Figure 8. Comparison of multipath method using the painter's algorithm vs the OpenGL's depth buffer implementation. It is plotting (a) the number of bundles vs error and (b) the number of bundles vs the time in seconds, for the big room scene. Figure 9. The images of the big room scene were obtained with Multipath with OpenGL depth buffer (upper) and with painter's algorithm (lower). Both images were generated with 4 million local rays for the first shot and 100 bundles for the indirect illumination. The rendering of the upper image took 5.75 seconds and the lower one seconds on a SGI Octane.

10 Figure 10. Comparison of multipath method using the painter's algorithm vs the OpenGL's depth buffer implementation. It is plotting the number of bundles vs the time in seconds for the office scene. Figure 11. The images of the office scene were obtained with Multipath with OpenGL's depth buffer (left) and with painter's algorithm (right). Both images were generated with 4 million local rays and 100 bundles. The second step took, for the left one, 5.8 seconds and the right one 37.3 seconds in a SGI Octane. On the other hand, the depth buffer implementation shows better results in open spaces. For example, in figure 9(a) the ceiling looks better than it looks in figure 9(b). Also in figure 11(a) and (b) we can see the difference between the ceilings' illumination.

11 5. Conclusions and future work In this paper we have presented a hardware based OpenGL depth buffer implementation of the multipath algorithm. The new algorithm exploits the coherence of the scene and instead of tracing many independent rays, it uses global ray bundles to transfer the radiosity. Note that a single bundle may correspond to a lot of bi-directional rays, which can be traced efficiently. We demonstrated that the tracing of this bundle can be computed by the graphics hardware. On an SGI Octane computer this exploitation of the graphics hardware increased the rendering speed by 7 times, and made it possible to render moderately complex radiosity scenes in a few seconds. Future work will be addressed to improve the results in areas where the distance between the patches is small. On the other hand, non-diffuse multipath version or other related global line Monte Carlo methods are also ideal target for using OpenGL depth buffer hardware implementations. 6. Acknowledgements This project has been funded in part with grant number TIC C03-01 of the Spanish Government, a Spanish-Hungarian Joint-Project, National Scientific Research Fund of Hungary (OTKA ref. No.: T029135), the Eötvös Foundation and the IKTA-00101/2000 project. Thanks go to Gonzalo Besuievsky for modeling the test scene and to Frederic Pérez for his valuable comments. References [1] Bekaert Ph., Hierarchical and Stochastic Algorithms for Radiosity, Ph. D. Dissertation, Department of Computer Science, Katholieke Universitiet Leuven, Leuven, Belgium, [2] Besuievsky G., Pueyo X., Making Global Monte Carlo Methods Useful: An Adaptive Approach for Radiosity, Congreso Espanol de Informática Gráfica CEIG'97, Barcelona, Spain, [3] Buckalew C., Fussell D., Illumination networks: Fast realistic rendering with general reflectance functions, Computer Graphics, (SIGGRAPH'89 Proceedings), 23(3), July 1989, pp [4] Castro F., Martínez R., Sbert M., Quasi Monte Carlo and extended first shot improvement to the multi-path method for radiosity, Proceedings of SCCG'98, Budmerice, Slovakia, April 1998.

12 [5] Martínez R., Szirmay-Kalos L., Sbert M., Adaptive Multipath with Bundles of Parallel Line, Visual2000, 3 rd International Conference on Visual Computing, Mexico D.F., September 18-22, [6] Neumann L., Monte Carlo Radiosity Computing, Springer-Verlag , pp [7] Santaló L. A., Integral Geometry and Geometric Probability. Addison-Wesley, New York, [8] Sbert M., An integral geometry based method for fast form factor computation. Computer Graphics Forum (Eurographics'93), 12(3): C409-C420, September [9] Sbert M, Pueyo X., Neumann L., Purgathofer W., Global multipath Monte Carlo algorithms for radiosity, The Visual Computer, [10] Sbert M., The use of global random directions to compute Radiosity. Global Monte Carlo Techniques. PhD. dissertation, Universitat Politécnica de Catalunya, Barcelona, March [11] Szirmay-Kalos L., Fóris T., Neumann L., Csébfalvi B., An analysis to quasi- Monte Carlo integration applied to the transillumination radiosity method, Computer Graphics Forum 16(3): , [12] Szirmay-Kalos L., Global Ray-Bundle tracing, Proceedings of the 9 th Eurographics Workshop on Rendering Vienna, June [13] Szirmay-Kalos L., Stochastic Iteration for Non-diffuse Global Illumination, Eurographics'99 Proccedings, Milano, September [14] Szirmay-Kalos L., Sbert M., Martínez R., Tobler R., Incoming first-shot for non-diffuse global illumination, Proceedings of SCCG 2000.