Radiosity

From Wikipedia, the free encyclopedia

Glass scene rendered in POV-Ray, demonstrating radiosity, photons, focal blur, and other photorealistic capabilities.

Radiosity is a global illumination algorithm used in 3D computer graphics rendering. Unlike direct illumination algorithms (such as ray tracing), which tend to simulate light reflecting only once off each surface, global illumination algorithms such as Radiosity simulate the many reflections of light around a scene, generally resulting in softer, more natural shadows.

As a rendering method, Radiosity was introduced in 1984 by researchers at Cornell University (C. Goral, K. E. Torrance, D. P. Greenberg and B. Battaile) in their paper "Modeling the interaction of light between diffuse surfaces". The theory had been in use in engineering to solve problems in radiative heat transfer since about 1950.

Notable commercial Radiosity engines have been Newtek's Lightwave internal render engine, Lightscape (now incorporated into the Autodesk 3D Studio Max internal render engine), and Radiozity by Auto*Des*Sys. Radiance, an open source Synthetic Image System that seeks physical accurate lightning effects, also makes use of the Radiosity method.

1 Visual characteristics
2 Physical characteristics
3 Limitations
4 External links

[edit] Visual characteristics

Demonstration of a hybrid of radiosity rendering and ray tracing

The inclusion of radiosity calculations in the rendering process often lends an added element of realism to the finished scene, because of the way it mimics real-world phenomena. Consider a red ball sitting on a white floor.

Light strikes the ball, casting a shadow, as well as reflecting a tiny amount of red light to surrounding objects — in this case, the floor. This phenomenon gives the white floor, in the vicinity of the ball, a reddish hue and is often referred to as "color bleeding". The effect is subtle, but since the human eye is accustomed to its counterpart in the real world, it helps create the illusion of realism.

[edit] Physical characteristics

The basic radiosity method has its basis in the theory of thermal radiation, since radiosity relies on computing the amount of light energy transferred between two surfaces. In order to simplify the calculations, the radiosity algorithm assumes that this amount is constant across the surfaces (perfect or ideal Lambertian surfaces); this means that to compute an accurate image, geometry in the scene description must be broken down into smaller areas, or patches, which can then be recombined for the final image.

After this breakdown, the amount of light energy transfer can be computed by using the known reflectivity of the reflecting patch, combined with the form factor of the two patches. This dimensionless quantity is computed from the geometric orientation of two patches, and can be thought of as the fraction of the total possible emitting area of the first patch which is covered by the second patch.

More correctly radiosity is the energy leaving the patch surface per discrete time interval and is the combination of emitted and reflected energy:

$B_i\, d A_i = E_i\, d A_i + R_i \int_j B_j F_{ji}\, d A_j,\,\!$

where:

B_i is the radiosity of patch i.
E_i is emitted energy.
R_i is the reflectivity of the patch, giving reflected energy by multiplying by the incident energy (the energy which arrives from other patches).
All j ( $j \ne i$ ) in the rendered environment are integrated for B_jF_ji dA_j, to determine the energy leaving each patch j that arrives at patch i.
F_ji is a constant form factor for the geometric relation between patch i and each patch j.

The reciprocity:

$F_{ij} A_i = F_{ji} A_j\,\!$

gives:

$B_i = E_i + R_i \int_j B_j F_{ij}\,\!$

For ease of use the integral is replaced and constant radiosity is assumed over the patch, creating the simpler:

$B_i = E_i + R_i \sum_{j=1}^n B_j F_{ij}$

This equation can then be applied to each patch. The equation is monochromatic, so color radiosity rendering requires calculation for each of the required colors.

The constant F_ji can be calculated in a number of ways. Early methods used a hemicube (an imaginary cube centered upon the first surface to which the second surface was projected, devised by Cohen and Greenberg in 1985) to approximate the form factor, which also solved the intervening patch problem. This is quite computationally expensive, because ideally form factors must be derived for every possible pair of patches, leading to a quadratic increase in computation with added geometry.

[edit] Limitations

As radiosity only deals with the global radiance transfer between objects, position-dependent effects such as reflection (including specular lighting) and refraction cannot be simulated directly with this method. However, some systems use hybrid approaches, making use of radiosity for illumination and ray tracing (or some other technique) for position-dependent effects.

[edit] External links

Radiosity Overview, from HyperGraph of SIGGRAPH (provides full matrix radiosity algorithm and progressive radiosity algorithm)
Radiosity, by Hugo Elias (also provides a general overview of lighting algorithms, along with programming examples)
Radiosity, by Allen Martin (a slightly more mathematical explanation of radiosity)
RADical, by Parag Chaudhuri (an implementation of shooting & sorting variant of progressive radiosity algorithm with OpenGL acceleration, extending from GLUTRAD by Colbeck)
ROVER, by Tralvex Yeap (Radiosity Abstracts & Bibliography Library)

Retrieved from "http://en.wikipedia.org../../../r/a/d/Radiosity.html"

Category: 3D computer graphics