PBRT笔记(4)——颜色和辐射度

SPD 光谱功率分布

CoefficientSpectrum

根据给定采样数表示光谱，为RGBSpectrum、SampledSpectrum的父类。

重载大量的基础代码，比较简单不做赘述。其中为了方便访问对应区域的SPD，而重载了[]操作符。（TabulatedBSSRDF等会用到）

该类只要以各种基础运算函数、重载各种操作符为主，以及一个 Float c[nSpectrumSamples];用于保存SPD信息。

SampledSpectrum

SampledSpectrum则将光谱表达为波长范围上的采样点集合。（通过采样求得光谱系数）

人眼对400~700纳米波长的光最敏感，通常采样量为30即可准确地表示渲染时的SPD

    static SampledSpectrum FromSampled(const Float *lambda, const Float *v,int n) {
        //如果处于无序状态，则在排序后在返回结果
         spectrum
        if (!SpectrumSamplesSorted(lambda, v, n)) {
            std::vector<Float> slambda(&lambda[0], &lambda[n]);
            std::vector<Float> sv(&v[0], &v[n]);
            //SortSpectrumSamples:讲sLambda与sv放入一个map中，使用sort进行排序后在放回对应的Vector
            //这里出现了一个骚操作，因为Vector存储的数据是紧挨着存储的和数组一样，所以可以直接用float*取地址进行操作
            SortSpectrumSamples(&slambda[0], &sv[0], n);
            return FromSampled(&slambda[0], &sv[0], n);
        }
        SampledSpectrum r;
        for (int i = 0; i < nSpectralSamples; ++i) {
            //计算该采样区域的平均值
            Float lambda0 = Lerp(Float(i) / Float(nSpectralSamples),
                                 sampledLambdaStart, sampledLambdaEnd);
            Float lambda1 = Lerp(Float(i + 1) / Float(nSpectralSamples),
                                 sampledLambdaStart, sampledLambdaEnd);
            r.c[i] = AverageSpectrumSamples(lambda, v, n, lambda0, lambda1);
        }
        return r;
    }

Float AverageSpectrumSamples(const Float *lambda, const Float *vals, int n,
                             Float lambdaStart, Float lambdaEnd) {
    for (int i = 0; i < n - 1; ++i) CHECK_GT(lambda[i + 1], lambda[i]);
    CHECK_LT(lambdaStart, lambdaEnd);
    //处理越界以及单一采样的情况
    if (lambdaEnd <= lambda[0]) return vals[0];
    if (lambdaStart >= lambda[n - 1]) return vals[n - 1];
    if (n == 1) return vals[0];
    Float sum = 0;
    //如果头尾采样都在区间内，则将其加入结果中
    if (lambdaStart < lambda[0]) sum += vals[0] * (lambda[0] - lambdaStart);
    if (lambdaEnd > lambda[n - 1])
        sum += vals[n - 1] * (lambdaEnd - lambda[n - 1]);

    //移动到对应的区间
    int i = 0;
    while (lambdaStart > lambda[i + 1]) ++i;
    CHECK_LT(i + 1, n);

    //遍历各个区间，通过插值计算平均值，最终加到结果中
    auto interp = [lambda, vals](Float w, int i) {
        return Lerp((w - lambda[i]) / (lambda[i + 1] - lambda[i]), vals[i],
                    vals[i + 1]);
    };
    for (; i + 1 < n && lambdaEnd >= lambda[i]; ++i) {
        Float segLambdaStart = std::max(lambdaStart, lambda[i]);
        Float segLambdaEnd = std::min(lambdaEnd, lambda[i + 1]);
        sum += 0.5 * (interp(segLambdaStart, i) + interp(segLambdaEnd, i)) *
               (segLambdaEnd - segLambdaStart);
    }
    return sum / (lambdaEnd - lambdaStart);
}

针对任意SPD转化为$ X_\lambda Y_\lambda Z _\lambda$的计算，PRBT通过三条曲线进行适配。
所有的Spectrum都必须提供这个方法。在渲染图片的一个像素时，一束携带光谱信息的光线射入摄像机中的胶片，第一步胶片会将SPD转化为xyz系数，再经过一系列处理，最终将其转化为可以显示的RGB值。

RGB系数根据基于SPD相应曲线积分计算获得。对于既定曲线，乘积积分可通过预计算实现，并将全转换表示为一个矩阵。

inline void XYZToRGB(const Float xyz[3], Float rgb[3]) {
    rgb[0] = 3.240479f * xyz[0] - 1.537150f * xyz[1] - 0.498535f * xyz[2];
    rgb[1] = -0.969256f * xyz[0] + 1.875991f * xyz[1] + 0.041556f * xyz[2];
    rgb[2] = 0.055648f * xyz[0] - 0.204043f * xyz[1] + 1.057311f * xyz[2];
}

inline void RGBToXYZ(const Float rgb[3], Float xyz[3]) {
    xyz[0] = 0.412453f * rgb[0] + 0.357580f * rgb[1] + 0.180423f * rgb[2];
    xyz[1] = 0.212671f * rgb[0] + 0.715160f * rgb[1] + 0.072169f * rgb[2];
    xyz[2] = 0.019334f * rgb[0] + 0.119193f * rgb[1] + 0.950227f * rgb[2];
}

void ToRGB(Float rgb[3]) const {
    Float xyz[3];
    ToXYZ(xyz);
    XYZToRGB(xyz, rgb);
}

RGBSpectrum

讲光谱系数转化为RGB值(先转成x、y、z，再转成RGB值)

static RGBSpectrum FromSampled(const Float *lambda, const Float *v, int n) {
    if (!SpectrumSamplesSorted(lambda, v, n)) {
        std::vector<Float> slambda(&lambda[0], &lambda[n]);
        std::vector<Float> sv(&v[0], &v[n]);
        SortSpectrumSamples(&slambda[0], &sv[0], n);
        return FromSampled(&slambda[0], &sv[0], n);
    }
    Float xyz[3] = {0, 0, 0};
    for (int i = 0; i < nCIESamples; ++i) {
        Float val = InterpolateSpectrumSamples(lambda, v, n, CIE_lambda[i]);
        xyz[0] += val * CIE_X[i];
        xyz[1] += val * CIE_Y[i];
        xyz[2] += val * CIE_Z[i];
    }
    Float scale = Float(CIE_lambda[nCIESamples - 1] - CIE_lambda[0]) /
                  Float(CIE_Y_integral * nCIESamples);
    xyz[0] *= scale;
    xyz[1] *= scale;
    xyz[2] *= scale;
    return FromXYZ(xyz);
}

Float InterpolateSpectrumSamples(const Float *lambda, const Float *vals, int n,
                                 Float l) {
    for (int i = 0; i < n - 1; ++i) CHECK_GT(lambda[i + 1], lambda[i]);
    if (l <= lambda[0]) return vals[0];
    if (l >= lambda[n - 1]) return vals[n - 1];
    int offset = FindInterval(n, [&](int index) { return lambda[index] <= l; });
    CHECK(l >= lambda[offset] && l <= lambda[offset + 1]);
    Float t = (l - lambda[offset]) / (lambda[offset + 1] - lambda[offset]);
    return Lerp(t, vals[offset], vals[offset + 1]);
}

因为这里的代码都要后面几章才会用到，看得不太明白，待看到后面几章后再补充。

剩下的辐射度部分比较简单（稍微介绍了一下brdf、btdf、bsdf、bssrdf，而且和第二版是一样的），而且知乎上已经有一些比较好的解释了，不做赘述。不过我依然建议去看原文。