diff --git a/src/integrators/photonmapper/photonmapper.cpp b/src/integrators/photonmapper/photonmapper.cpp
index cbc847fa..caae6ef9 100644
--- a/src/integrators/photonmapper/photonmapper.cpp
+++ b/src/integrators/photonmapper/photonmapper.cpp
@@ -75,7 +75,7 @@ MTS_NAMESPACE_BEGIN
* }
*
* When the scene contains participating media, the Beam Radiance Estimate \cite{Jarosz2008Beam}
- * is used to estimate the illumination due to volumetric scattering.
+ * by Jarosz et al. is used to estimate the illumination due to volumetric scattering.
*
* \remarks{
* \item Currently, only homogeneous participating media are supported by this implementation
diff --git a/src/mtsgui/resources/docs.xml b/src/mtsgui/resources/docs.xml
index f713104b..1bc04460 100644
--- a/src/mtsgui/resources/docs.xml
+++ b/src/mtsgui/resources/docs.xml
@@ -1,19 +1,5 @@
This integrator implements a hardware-accelerated global illumination
+ rendering technique based on the Instant Radiosity method by Keller.
+ This is the same approach that is also used in
+ Mitsuba's real-time preview; the reason for providing it as a separate
+ integrator plugin is to enable automated (e.g. scripted) usage. The method roughly works as follows: during a pre-process pass, any present direct
+ and indirect illumination is converted into a set of virtual point light
+ sources (VPLs). The scene is then separately rendered many times, each time using
+ a different VPL as a source of illumination. All of the renderings created in this
+ manner are accumulated to create the final output image. Because the individual rendering steps can be exectuted on a
+ graphics card, it is possible to render many (i.e. 100-1000) VPLs
+ per second. The method is not without problems, however. In particular,
+ it performs poorly when rendering glossy materials, and it produces
+ artifacts in corners and creases . Mitsuba automatically limits
+ the "glossyness" of materials to reduce the effects of the former
+ problem. A clamping parameter is provided to control the latter
+ (see the documentation for details). The number of samples per pixel specified to
+ the sampler is interpreted as the number of VPLs that should be rendered.
When the scene contains homogeneous participating media, the Beam Radiance Estimate by Jarosz et al. + is used to estimate the illumination due to volumetric scattering.
Number of luminaire samples for direct illumination Number of glossy samples for direct illumination @@ -350,17 +355,31 @@This plugin implements the progressive photon mapping algorithm by Hachisuka et al. + Progressive photon mapping is a variant of photon + mapping that alternates between photon shooting and gathering passes that involve + a relatively small (e.g. 250K) numbers of photons that are subsequently discarded.
+ +This is done in a way such that the variance and bias of the resulting output + vanish as the number of passes tends to infinity. The progressive nature of this + method enables renderings with an effectively arbitrary number of photons + without exhausting the available system memory.
+ +The desired sample count specified in the sample generator configuration + determines how many photon query points are created per pixel. It should not be + set too high, since the rendering time is approximately proportional to + this number. For good results, use between 2-4 samples along with the + low-discrepancy sampler. Once started, the rendering process continues indefinitely + until it is manually stopped.
This integrator implements stochastic progressive photon mapping (PPM) by Hachisuka et al. + This algorithm is an extension of progressive photon mapping that improves convergence + when rendering scenes involving depth-of-field, motion blur, and glossy reflections.
+ +Note that this integrator ignores the sampler + configuration---hence, the usual steps of choosing a sample generator and a desired + number of samples per pixel are not necessary. As with PPM, once started, + the rendering process continues indefinitely until it is manually stopped.
Primary Sample Space Metropolis Light Transport (PSSMLT) is a rendering + technique developed by Kelemen et al. which is + based on Markov Chain Monte Carlo (MCMC) integration.
+ +In contrast to simple methods like path tracing that render + images by performing a naive and memoryless random search for light paths, + PSSMLT actively searches for relevant light paths (as is the case + for other MCMC methods). Once such a path is found, the algorithm tries to + explore neighboring paths to amortize the cost of the search. This can + significantly improve the convergence rate of difficult input. + Scenes that were already relatively easy to render usually don't benefit + much from PSSMLT, since the MCMC data management causes additional + computational overheads.
+ +The PSSMLT implementation in Mitsuba can operate on top of either a simple + unidirectional volumetric path tracer or a fully-fledged bidirectional path + tracer with multiple importance sampling, and this choice is controlled by the + bidirectional flag. The unidirectional path tracer is generally + much faster, but it produces lower-quality samples. Depending on the input, either may be preferable.
+ +Caveats: + There are a few general caveats about MLT-type algorithms that are good + to know. The first one is that they only render "relative" output images, + meaning that there is a missing scale factor that must be applied to + obtain proper scene radiance values. The implementation in Mitsuba relies + on an additional Monte Carlo estimator to recover this scale factor. By + default, it uses 100K samples (controlled by the luminanceSamples + parameter), which should be adequate for most applications.
+ +The second caveat is that the amount of computational expense + associated with a pixel in the output image is roughly proportional to + its intensity. This means that when a bright object (e.g. the sun) is + visible in a rendering, most resources are committed to rendering the + sun disk at the cost of increased variance everywhere else. Since this is + usually not desired, the twoStage parameter can be used to + enable Two-stage MLT in this case.
+ +In this mode of operation, the renderer first creates a low-resolution + version of the output image to determine the approximate distribution of + luminance values. The second stage then performs the actual rendering, while + using the previously collected information to ensure that + the amount of time spent rendering each pixel is uniform.
+ +The third caveat is that, while PSMLT can work with scenes that are extremely + difficult for other methods to handle, it is not particularly efficient + when rendering simple things such as direct illumination (which is more easily + handled by a brute-force type algorithm). By default, the + implementation in Mitsuba therefore delegates this to such a method + (with the desired quality being controlled by the directSamples parameter). + In very rare cases when direct illumination paths are very difficult to find, + it is preferable to disable this separation so that PSSMLT is responsible + for everything. This can be accomplished by setting + directSamples=-1.