# Renderers

Various techniques to render images

The renderer is the most important part of the framework, implementing the techniques to generate images. Currently we implemented some Monte Carlo method based rendering techniques for comparision and verification. The most of rendering techniques are parallelized to facilitate the power of the multi-core processor. The renderer is specified by the renderer element in the scene file.

renderer:
type: <renderer_type>
params:
<parameters_for_renderer>
...


## Common parameters

### Parallelization

Some basic parameters are common between all renderers. For the renderer with parallization, we utilized the following parameters for all renderers.

• num_threads
• Number of threads for parallelization
• If num_threads <= 0, (# of logical cores) + num_threads threads are utilizes for computation. For instance, if num_threads = -1 and the number of logical cores are 8, the actual number of threads utilized for computation is 8+(-1)=7.
• Default value: 0
• grain_size
• Granuity of the parallelization
• Default value: 10000
• progress_update_interval
• Interval of the progress update in seconds
• Default value: 100000

### Controlling quality

Parameters for controlling render quality. The most of the technique are based on randomness and the quality of the rendering based on how many time we spend for computation. Intuitively if we take much time, the quality is improved. However there is no fixed criteria for rendering time, so the user is recommended to control the appropriate computation time sutable for your requirements.

• num_samples: Number of samples utilized for rendering
• render_time: Rendering time in seconds

Note that these two parameters are exclusive. That is, we cannot use num_sample and render_time in the same time.

## Rendering techniques

### Path tracing

#### Type

• pt: w/o direct light samping (a.k.a. next event estimation)
• ptdirect: w/ direct light samping

#### Description

This renderer implements Kajiya’s path tracing. Path tracing is the most basic Monte Carlo method based rendering technique. The technique traces lights from the sensor until the ray reaches to the light source.

### Light tracing

#### Type

• lt: w/o direct sensor samping (mainly for debugging)
• ltdirect: w/ direct sensor sampling
• For the scenes with pihole camera lt generates black images because there is not way to intersect with pinhole.

#### Description

Unlike path tracing, the renderer traces the ray from the lights from the light sources until it reaches to the sensor. Also we implemented two versions, with and without direct sensor sampling to sample directly from the intersected points.

### Bidirectional path tracing

#### Type

bdpt

#### Description

The renderer implements bidirectional path tracings. Bidirectional path tracing traces the paths both from light sources and the sensor. We can obtain various combination of paths connecting different intersected points. We can obtain better estimate of the path energy by combining these light paths.