PBRT_V2 总结记录 <106> SingleScatteringIntegrator

aa20274270

于 2019-01-10 15:03:17 发布

阅读量261

点赞数

分类专栏： PBRT_V2

本文链接：https://blog.csdn.net/aa20274270/article/details/86231060

版权

PBRT_V2 专栏收录该内容

113 篇文章 3 订阅

订阅专栏

SingleScatteringIntegrator 是PBRT中的一种积分器，它考虑了直接光照的影响，忽略多次散射的贡献。Li()方法估计参与介质的发射和散射光。该方法使用与EmissionIntegrator类似的光线遍历方法，但在光线通过参与介质时，还需计算从光源到散射点及从散射点到光线起点的衰减。主要区别在于内部先生成光源样本，并使用不同模式选择光源和其组件。计算直接光照贡献时，采用UniformSampleOneLight策略，最终累加得到直接光照效果。

摘要由CSDN通过智能技术生成

SingleScatteringIntegrator

class SingleScatteringIntegrator : public VolumeIntegrator {
public:
    // SingleScatteringIntegrator Public Methods
    SingleScatteringIntegrator(float ss) { stepSize = ss; }
    Spectrum Transmittance(const Scene *, const Renderer *,
        const RayDifferential &ray, const Sample *sample, RNG &rng,
        MemoryArena &arena) const;
    void RequestSamples(Sampler *sampler, Sample *sample,
        const Scene *scene);
    Spectrum Li(const Scene *, const Renderer *, const RayDifferential &ray,
         const Sample *sample, RNG &rng, Spectrum *T, MemoryArena &arena) const;
private:
    // SingleScatteringIntegrator Private Data
    float stepSize;
    int tauSampleOffset, scatterSampleOffset;
};

作用：

（SingleScatteringIntegrator 中，ray中每一个点除了有 emission 的效果之外，还有直接光照的效果，只考虑直接光照，那么对应的下面的公式，就是 participating media 的 emission and in-scattered 的部分）

In addition to accounting for the emission at each point along the ray, the Single
ScatteringIntegrator also considers the incident radiance due to direct illumination
but ignores incident radiance due to multiple scattering. Thus, its Li() method estimates
the integral

where Ld only includes radiance from direct lighting. This radiance may be blocked
by geometry in the scene and may itself be attenuated by participating media between
the light and the point p‘ along the ray (Figure 16.6).

Figure 16.6: When the direct lighting contribution is evaluated at some point t along a ray passing
through participating media, it’s necessary to compute the attenuation of the radiance from the light
passing through the volume to the scattering point as well as the attenuation from that point back to
the ray origin.


Spectrum SingleScatteringIntegrator::Li(const Scene *scene, const Renderer *renderer,
        const RayDifferential &ray, const Sample *sample, RNG &rng,
        Spectrum *T, MemoryArena &arena) const {
    VolumeRegion *vr = scene->volumeRegion;
    float t0, t1;
    if (!vr || !vr->IntersectP(ray, &t0, &t1) || (t1-t0) == 0.f) {
        *T = 1.f;
        return 0.f;
    }
    // Do single scattering volume integration in _vr_
    Spectrum Lv(0.);

    // Prepare for volume integration stepping
    int nSamples = Ceil2Int((t1-t0) / stepSize);
    float step = (t1 - t0) / nSamples;
    Spectrum Tr(1.f);
    Point p = ray(t0), pPrev;
    Vector w = -ray.d;
    t0 += sample->oneD[scatterSampleOffset][0] * step;

    // Compute sample patterns for single scattering samples
    float *lightNum = arena.Alloc<float>(nSamples);
    LDShuffleScrambled1D(1, nSamples, lightNum, rng);
    float *lightComp = arena.Alloc<float>(nSamples);
    LDShuffleScrambled1D(1, nSamples, lightComp, rng);
    float *lightPos = arena.Alloc<float>(2*nSamples);
    LDShuffleScrambled2D(1, nSamples, lightPos, rng);
    uint32_t sampOffset = 0;
    for (int i = 0; i < nSamples; ++i, t0 += step) {
        // Advance to sample at _t0_ and update _T_
        pPrev = p;
        p = ray(t0);
        Ray tauRay(pPrev, p - pPrev, 0.f, 1.f, ray.time, ray.depth);
        Spectrum stepTau = vr->tau(tauRay,
                                   .5f * stepSize, rng.RandomFloat());
        Tr *= Exp(-stepTau);

        // Possibly terminate ray marching if transmittance is small
        if (Tr.y() < 1e-3) {
            const float continueProb = .5f;
            if (rng.RandomFloat() > continueProb) {
                Tr = 0.f;
                break;
            }
            Tr /= continueProb;
        }

        // Compute single-scattering source term at _p_
        Lv += Tr * vr->Lve(p, w, ray.time);
        Spectrum ss = vr->sigma_s(p, w, ray.time);
        if (!ss.IsBlack() && scene->lights.size() > 0) {
            int nLights = scene->lights.size();
            int ln = min(Floor2Int(lightNum[sampOffset] * nLights),
                         nLights-1);
            Light *light = scene->lights[ln];
            // Add contribution of _light_ due to scattering at _p_
            float pdf;
            VisibilityTester vis;
            Vector wo;
            LightSample ls(lightComp[sampOffset], lightPos[2*sampOffset],
                           lightPos[2*sampOffset+1]);
            Spectrum L = light->Sample_L(p, 0.f, ls, ray.time, &wo, &pdf, &vis);
            
            if (!L.IsBlack() && pdf > 0.f && vis.Unoccluded(scene)) {
                Spectrum Ld = L * vis.Transmittance(scene, renderer, NULL, rng, arena);
                Lv += Tr * ss * vr->p(p, w, -wo, ray.time) * Ld * float(nLights) /
                        pdf;
            }
        }
        ++sampOffset;
    }
    *T = Tr;
    return Lv * step;
}

作用：

（这里的Li函数，大部分代码都是和 EmissionIntegrator 比较类似，可以参考《PBRT_V2 总结记录 <105> EmissionIntegrator》，这个Li 函数，最主要的就是计算直接光照的效果。）

This integrator’s Li() method uses the same general ray-marching approach to evaluate
the equation of transfer as the EmissionIntegrator.

细节

    // Compute sample patterns for single scattering samples
    float *lightNum = arena.Alloc<float>(nSamples);
    LDShuffleScrambled1D(1, nSamples, lightNum, rng);
    float *lightComp = arena.Alloc<float>(nSamples);
    LDShuffleScrambled1D(1, nSamples, lightComp, rng);
    float *lightPos = arena.Alloc<float>(2*nSamples);
    LDShuffleScrambled2D(1, nSamples, lightPos, rng);

作用：

（先获得采样光源的采样点）

One difference is that this one computes
sample values for light source sampling before it enters the for loop over sample
positions. Because it isn’t known how many samples will be necessary until Li() is called

(since this number depends on the length of the ray segment over which integration is being
done), it’s not possible to have the Sampler generate samples and pass them into Li()
via the Sample. Therefore, the samples are generated here. Two one-dimensional patterns
are used for selecting which light to sample and which light component to sample, and a
two-dimensional pattern is used for selecting points on area light sources.

        // Compute single-scattering source term at _p_
        Lv += Tr * vr->Lve(p, w, ray.time);
        Spectrum ss = vr->sigma_s(p, w, ray.time);
        if (!ss.IsBlack() && scene->lights.size() > 0) {
            int nLights = scene->lights.size();
            int ln = min(Floor2Int(lightNum[sampOffset] * nLights),
                         nLights-1);
            Light *light = scene->lights[ln];
            // Add contribution of _light_ due to scattering at _p_
            float pdf;
            VisibilityTester vis;
            Vector wo;
            LightSample ls(lightComp[sampOffset], lightPos[2*sampOffset],
                           lightPos[2*sampOffset+1]);
            Spectrum L = light->Sample_L(p, 0.f, ls, ray.time, &wo, &pdf, &vis);
            
            if (!L.IsBlack() && pdf > 0.f && vis.Unoccluded(scene)) {
                Spectrum Ld = L * vis.Transmittance(scene, renderer, NULL, rng, arena);
                Lv += Tr * ss * vr->p(p, w, -wo, ray.time) * Ld * float(nLights) /
                        pdf;
            }
        }
        ++sampOffset;

作用：

（参考公式： , 上面主要就是计算这个公式，而且，在计算第二个积分的时候，采用了 UniformSampleOneLight 的思路（参考《PBRT_V2 总结记录 <97> DirectLightingIntegrator》），所以最后的

Lv += Tr * vr->Lve(p, w, ray.time) + Tr * ss * vr->p(p, w, -wo, ray.time) * Ld * float(nLights) / pdf;

最后累积完Lv 之后，再进行 Lv * step，这两个步骤就是直接执行公式：

）

After including volume emission in
the same way that the EmissionIntegrator does, it finds the value of σs at the point,
selects a light to sample, and computes its contribution to scattering at the point. Because
the source term is generally evaluated at many points along the ray, only a single light is
sampled at each one, and its contribution is scaled by the number of lights, similar to the
direct lighting integrator’s “sample one light” strategy.

Computing the estimate of the direct lighting contribution at a point p involves estimating
the integral

Rather than sampling both the phase function and the light source and applyingmultiple
importance sampling, the implementation here always lets the light choose a sample
position on the light source and then computes the estimator directly. For media that
aren’t extremely anisotropic, this approach works well.