Radiosity Computer Graphics: Advancing Visualization through Radiosity in Computer Vision

By Fouad Sabry

What is Radiosity Computer Graphics

In 3D computer graphics, radiosity is an application of the finite element method to solving the rendering equation for scenes with surfaces that reflect light diffusely. Unlike rendering methods that use Monte Carlo algorithms, which handle all types of light paths, typical radiosity only account for paths which leave a light source and are reflected diffusely some number of times before hitting the eye. Radiosity is a global illumination algorithm in the sense that the illumination arriving on a surface comes not just directly from the light sources, but also from other surfaces reflecting light. Radiosity is viewpoint independent, which increases the calculations involved, but makes them useful for all viewpoints.

How you will benefit

(I) Insights, and validations about the following topics:

Chapter 1: Radiosity (computer graphics)

Chapter 2: Rendering (computer graphics)

Chapter 3: Global illumination

Chapter 4: Ray tracing (graphics)

Chapter 5: Phong reflection model

Chapter 6: Metropolis light transport

Chapter 7: Photon mapping

Chapter 8: Shading

Chapter 9: Ray casting

Chapter 10: Rendering equation

(II) Answering the public top questions about radiosity computer graphics.

(III) Real world examples for the usage of radiosity computer graphics in many fields.

Who this book is for

Professionals, undergraduate and graduate students, enthusiasts, hobbyists, and those who want to go beyond basic knowledge or information for any kind of Radiosity Computer Graphics.

• Language: English
• Publisher: One Billion Knowledgeable
• Release date: May 13, 2024

Book preview

Chapter 1: Radiosity (computer graphics)

Radiosity is a finite element method application used in 3D computer graphics to solve the rendering equation for scenes with diffusely reflecting surfaces. Typical radiosity only takes into account light paths (represented by the code LD*E) that leave a light source and are reflected diffusely a certain number of times (possibly zero) before hitting the eye. This is in contrast to rendering techniques that use Monte Carlo algorithms (such as path tracing), which handle all types of light paths. In the sense that lighting reaching a surface comes from both direct light sources and additional surfaces that reflect light, radiosity is a global illumination method. Since radiosity is viewpoint independent, more calculations are required yet are still beneficial from all perspectives.

The first radiosity techniques were created in the engineering discipline of heat transfer about 1950. In 1984, researchers at Cornell University improved them expressly for the issue of generating computer images.

Commercial radiosity engines like Enlighten by Geomerics are noteworthy (used for games including Battlefield 3 and Need for Speed: The Run); 3ds Max; form•Z; Electric Image Animation System with LightWave 3D.

Because it mirrors real-world occurrences, the incorporation of radiosity computations in the rendering process frequently adds a layer of realism to the final scene. Think about a plain room setting.

A conventional direct illumination renderer was used to create the image on the left. Three types of lighting have been specifically chosen and positioned by the artist in this scene in an effort to create realistic lighting: omnidirectional lighting without shadows, ambient lighting, and spot lighting with shadows (placed outside the window to create the light shining on the floor) (to reduce the flatness of the ambient lighting).

A radiosity method was used to render the image to the right. An picture of the sky displayed outside the window serves as the sole source of light. The distinction is obvious. Light floods the space. There are soft shadows on the floor and delicate lighting effects throughout the space. In addition, the grey walls now appear a little bit warmer due to the red hue of the carpet leaking onto them. These effects weren't chosen or created by the artist with any particular intent.

Each of the rendered scene's surfaces is broken down into one or more smaller surfaces (patches). Each pair of patches has a view factor, also known as a form factor, which is a coefficient defining how effectively the patches can see one another. Smaller view factors will be present for patches that are farther apart or placed at an angle to one another. The view factor will be lower or zero if additional patches are in the way, depending on whether the occlusion is total or partial.

The coefficients in a linear set of rendering equations are the view factors. By solving this system and accounting for diffuse interreflections and soft shadows, the radiosity, or brightness, of each patch is obtained.

With intermediate radiosity values for the patch, which correspond to bounce levels, progressive radiosity solves the system iteratively. That is, following each iteration, we are aware of how the scene appears following a single light bounce, two passes, two bounces, and so on. Using this, you can see an interactive scene preview. Additionally, rather of waiting for the process to numerically converge, the user can stop the iterations once the image appears good enough.

Shooting radiosity, which iteratively solves the radiosity equation by shooting light from the patch with the most energy at each step, is another typical approach. After the initial pass, a light-emitting patch will only illuminate patches that are directly in its line of sight. After the second pass, as the light starts to refract around the scene, additional areas will start to glow. The scene gets brighter and brighter until it reaches a constant state.

Since radiosity relies on calculating the amount of light energy transmitted among surfaces, the basic radiosity approach is based on the theory of thermal radiation. The approach makes the assumption that all scattering is perfectly diffuse in order to streamline calculations. Typically, surfaces are discretized into quadrilateral or triangular elements, and a piecewise polynomial function is defined over these elements.

Following this breakdown, the known reflectivity of the reflecting patch along with the view factor of the two patches may be used to calculate the amount of light energy transfer. This dimensionless quantity is calculated from the geometric alignment of two patches and can be conceptualized as the percentage of the first patch's total emitting area that the second patch covers.

Better defined as the sum of energy emitted and reflected, radiosity B is the energy per unit area leaving the patch surface every discrete time interval:

B(x)\,dA=E(x)\,dA+\rho (x)\,dA\int _{{S}}B(x'){\frac {1}{\pi r^{2}}}\cos \theta _{x}\cos \theta _{{x'}}\cdot {\mathrm {Vis}}(x,x')\,{\mathrm d}A'

where:

B(x)i dAi is the total energy leaving a small area dAi around a point x.

E(x)i dAi is the emitted energy.

ρ(x) is the reflectivity of the point, multiplying the incident energy per unit area by the reflected energy per unit area (the total energy which arrives from other patches).

S indicates that the scene's surfaces are covered by the integration variable x'.

The distance r between two points x and x'

θx and θx' are the angles between the line joining x and x' and vectors normal to the surface at x and x' respectively.

The visibility function Vis(x,x') is specified to be 1 if two points x and x' can be seen from one another and 0 if not.

If a limited number of planar patches are used to approximate the surfaces, each of which is taken to have a constant radiosity Bi and reflectivity ρi, The discrete radiosity equation is given by the previous equation, B_{i}=E_{i}+\rho _{i}\sum _{{j=1}}^{n}F_{{ij}}B_{j}

where Fij is the geometrical view factor for the radiation leaving j and hitting patch i.

Then, each patch can be subjected to this equation. Since the equation is monochromatic, each of the necessary colors must be calculated in order to render color radiosity.

Formally, the equation can be solved as a matrix equation to provide a vector solution:

B=(I-\rho F)^{{-1}}E\;

This directly provides B with the complete infinite bounce solution.

However the number of calculations to compute the matrix solution scales according to n³, where n is the quantity of patches.

For n values that are realistically huge, this becomes prohibitive.

Instead, Iteratively solving the equation is easier, applying the single-bounce update algorithm repeatedly.