radiosity

Radiosity is a rendering method which works by not only refracting light from the light source off a 3D object(s), but it also takes the original light color + the surface color and avarages the light color of the new ray.

The are two main weaknesses with radiosity; computer load and specular surfaces, but there are ways to go about this

Computer load
An interesting approach to go about this problem is to implement methods such as the Monte Carlo method, which alters the exactness of the solutions to the energy equations calculated.

Specular surfaces
Even if the radiosity method results in almost perfect diffuse surfaces, the specular aspects of reflection and refraction is obliviated. This can be solved by also using the ray tracing method wich results in perfect specular surfaces but leaves the diffuse virtually untouched. Thus, combining these methods enhances the result.

The radiosity method is yet another global illumination rendering method for computer graphics, similar to ray tracing in that respect, but while ray tracing models global specular illumination, radiosity is capable of modeling global diffuse illumination. Unlike most other conventional rendering methods, there is no ambient light term (which really is a very crummy way of approximating global diffuse interreflections), and every surface is considered as an emitter or reflector of diffuse illumination that obeys Lambert's Law. The diffuse illumination computations are view-independent, meaning they have to be done only once for a particular scene, and provided the scene geometry doesn't change, the same computations can be used to render the same scene from a different viewpoint. This rendering method is very powerful, capable of rendering penumbrae (soft shadows) and color bleeding effects convincingly, among other things, and can create highly compelling photorealistic renderings. Often radiosity demo images show an actual picture of a scene along with with a 3D model of the same scene at the same viewpoint for comparison.

The most common form of radiosity algorithm is actually an algorithm for solving radiative heat transfer problems using finite element methods adapted to computer graphics rendering. The algorithm in its most basic form subdivides the entire scene into finite-sized polygonal patches, and attempts to compute a radiosity (diffuse light emission intensity) for the patch, which is computed from its own emitted radiosity (if any) and the radiosity contributions of all other patches in the environment. Once a final answer for the radiosity has been obtained, this is used to compute a color for the patch, which is usually used as an intensity in a Gouraud shader for the final rendering.

The radiosities are computed by solving a large system of linear equations, with one equation for every patch, each equation with as many terms as there are patches, because it's possible for every other patch in the scene to contribute to the radiosity of any given patch (although in practice only a few patches greatly influence the calculated radiosity of any given patch). These large equation systems are frequently solved using Gauss-Seidel iteration, which is designed to cope with the large equation systems that are typical in finite-element problems.

The jth term in the ith equation in the radiosity matrix contains a dimensionless term called a form factor, which measures how much the radiosity of patch j will contribute to the radiosity of patch i, i.e. how much each patch can "see" of some other patch. These form factors are generally very difficult to compute exactly except in the most simple of environments. The original paper by Goral et. al. used contour integrals to compute exact form factors in their very simple scene (the interior of a cube with colored faces). Algorithms were soon developed for computing approximate form factors efficiently, the most well known being the hemicube algorithm developed by Pat Hanrahan. Ray tracing has also been adapted to aid in the calculation of approximate form factors as well.

As one might imagine, the memory and processing requirements for even a modest radiosity simulation can be prodigious, far more so than ray tracing: a scene of medium complexity that has been subdivided into a million patches would require a matrix with one trillion coefficients, and the computation of a trillion form factors. Fortunately, a technique called substructuring has been developed for adaptively subdividing surfaces into patches, creating more patches where the radiosity gradient is estimated to be high (such as near a shadow boundary), and less where the gradient is low. There has also been progress in the development of progressive refinement radiosity algorithms that compute incremental solutions that can be refined to better ones later on.