【Ray Tracing The Next Week 超详解】光线追踪2-4 Perlin noise

Preface

为了得到更好的纹理，很多人采用各种形式的柏林噪声（该命名来自于发明人 Ken Perlin）

柏林噪声是一种比较模糊的白噪声的东西：（引用书中一张图）

柏林噪声是用来生成一些看似杂乱无章其实有些变换规律的图形（更加贴近自然），比如海水、地形、雾等

当然这里面的原理涉及分形几何等相关的知识

例如，2D柏林噪声可以生成

以及一些网上的总结：

还有一些其他的图

是不是看起来自然多了

那么今天，我们就来领略一下随机技术带来的自然之美~

Chapter 4：Perlin Noise

柏林噪声有2个关键的特点：

第一，输入相同的3D点，总能返回相同的随机值

第二，简单快捷，使用一些hack的方法，达到快速近似的效果。

关于随机数：

许多人在他们的程序中使用“随机数产生器”，以使得物体的运动行为更加自然，或者用来生成纹理。随机数产生器在一些情况下很有用，比如用在模拟自然物体的地方，如地形，海水等。

自然物体通常是分形的，有各种各样的层次细节，比如山的轮廓，通过高度区分就有高山(mountain,高度变化大)、山丘(hill，高度变化适中)、巨石(高度变化小) 、石头(高度变化很小)等。另外，比如草地、海浪、跑动的蚂蚁、摇晃的树枝、风、大理石的花纹等等，这些都呈现出了或大或小的细节变化。Perlin噪声函数通过噪声函数来模拟这些自然景观。

要构造一个Perlin函数，首先需要一个噪声函数和一个插值函数。

我们第一步当然是构建一个Perlin的类

class Perlin
    {
public:

    inline rtvar noise(const rtvec& p)const;

    inline static rtvar* randomvalue() { return _randomvalue; }

    inline static int* perm_x() { return _perm_x; }

    inline static int* perm_y() { return _perm_y; }

    inline static int* perm_z() { return _perm_z; }

public:

    static rtvar* perlin_generate();

    static int* perlin_generate_perm();

    static void permute(int* p, int n);

private:

    static rtvar* _randomvalue;

    static int* _perm_x;

    static int* _perm_y;

    static int* _perm_z;
    };

我们来介绍一下，第一个public包含的是和该类相关的成员函数

第二个public是我们的随机数生成函数，它们按理说应该和此类无关，但是放在类外，担心污染命名空间，所以暂时列为静态函数成员，毕竟它们和Perlin类有很大关系，最后的时候，再把所有的功能性全局函数封装到3D泛型库里面

类数据成员：分别是Perlin随机函数生成的随机序列以及三个方向的辅助随机分量序列

我们如下设置这三个随机函数

rtvar * Perlin::perlin_generate()
    {
    rtvar* p = new rtvar[256];
    for (int i = 0; i < 256; ++i)    p[i] = lvgm::rand01();
    return p;
    }

int* Perlin::perlin_generate_perm()
    {
    int * p = new int[256];
    for (int i = 0; i < 256; ++i)    p[i] = i;
    permute(p, 256);
    return p;
    }

void Perlin::permute(int * p, int n)
    {
    for (int i = n - 1; i > 0; --i)
        {
        int target = int(lvgm::rand01() * (i + 1));
        stds swap(p[i], p[target]);
        }
    }

然后用它们初始化静态数据成员

rtvar* Perlin::_randomvalue = Perlin::perlin_generate();

int* Perlin::_perm_x = Perlin::perlin_generate_perm();

int* Perlin::_perm_y = Perlin::perlin_generate_perm();

int* Perlin::_perm_z = Perlin::perlin_generate_perm();

其中，总随机序列由第一种方法生成，序列中的每一个元素均为0~1的随机数

分量的随机序列由第二种方法生成，即，初始序列为1-255，之后遍历整个序列，当前位置和一个随机生成的位置进行交换，已达到序列随机化

随机函数讲完了，我们来看一下产生噪声值的函数

u，v，w是插值时候用的，目前暂时不用

参数p为空间某点的位置（未经归一化或单位化）

上面的函数也很好懂，就不细说了

我们暂时先不管插值函数，我们先用这个试一下效果

class noise_texture :public texture
    {
public:
    noise_texture() {  }

    virtual rtvec value(rtvar u, rtvar v, const rtvec& p)const override;
    
private:
    Perlin _noise;
    };


rtvec noise_texture::value(rtvar u, rtvar v, const rtvec& p)const
    {
    return rtvec(1, 1, 1) * _noise.noise(p);
    }

就是把原来的噪声值腾个地方，转个手，没什么变化

然后主函数中

相机参数依然是：（以后默认是这个）

得到的效果是这样的：

其实还有个中间产品，之前把noise中的最后一行写成了

return _randomvalue[_perm_x[i] ^ _perm_y[i] ^ _perm_z[i]];

结果得到了下图（未做到完全随机）

感觉这个手误形成图也挺好看的

第一个图片看起来有点生硬粗糙，不是很光滑，所以，我们采用线性插值光滑一下

rtvar Perlin::trilinear_interp(rtvar c[2][2][2], rtvar u, rtvar v, rtvar w)
    {
    rtvar accumulate = 0;
    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < 2; ++j)
            for (int k = 0; k < 2; ++k)
                accumulate +=
                (i * u + (1 - i)*(1 - u))*
                (j * v + (1 - j)*(1 - v))*
                (k * w + (1 - k)*(1 - w))*
                c[i][j][k];
    return accumulate;
    }

我们把插值函数加入到noise函数中，当然你也可以尝试其他的插值函数

inline rtvar Perlin::noise(const rtvec& p)const
    {
    int i = floor(p.x());
    int j = floor(p.y());
    int k = floor(p.z());

    rtvar u = p.x() - i;
    rtvar v = p.y() - j;
    rtvar w = p.z() - k;

    rtvar list[2][2][2];
    for (int a = 0; a < 2; ++a)
        for (int b = 0; b < 2; ++b)
            for (int c = 0; c < 2; ++c)
                list[a][b][c] = _randomvalue[_perm_x[(i + a) & 255] ^ _perm_y[(j + b) & 255] ^ _perm_z[(k + c) & 255]];
    
    return trilinear_interp(list, u, v, w);
    }

我们同时采用了随机生成函数和插值函数

我们还可以再尝试一下利用Hermit Cubic来进行舍入插值

它的频率依旧有点低，我们可以对参数施加一定的缩放比例，加速它的变化

也就是图像中的颜色更迭的太慢（I think）

class noise_texture :public texture
    {
public:
    noise_texture() {  }

    noise_texture(const rtvar scale);    

    virtual rtvec value(rtvar u, rtvar v, const rtvec& p)const override;
    
private:
    Perlin _noise;

    rtvar _scale;
    };



noise_texture::noise_texture(const rtvar scale)
    :_scale(scale)
    {
    }

rtvec noise_texture::value(rtvar u, rtvar v, const rtvec& p)const
    {
    return rtvec(1, 1, 1) * _noise.noise(_scale * p);
    }

下面是scale 为 15 的图像

看起来密集多了，颜色变换频率也快了

下面是scale 为 1.5 的图像

显然，上面的图像格点还是很明晰的，可能是因为最小值和最大值总是精确地落在整数x / y / z上。 Ken Perlin采用了另一种技巧，将随机单位向量（而不仅仅是浮点数）放在格点上，并使用点积来移动格子的最小值和最大值。

所以，首先我们需要将随机浮点数更改为随机向量，试一试新的方法

下面是书上的代码，你运行之后打不开图像文件，因为里面是错的，我们边看边数说哪里错了

我们需要把数据成员_randomvalue改为static rtvec*

所以初始化语句也要改

rtvec * Perlin::_randomvalue = Perlin::perlin_generate();

int * Perlin::_perm_x = Perlin::perlin_generate_perm();

int * Perlin::_perm_y = Perlin::perlin_generate_perm();

int * Perlin::_perm_z = Perlin::perlin_generate_perm();

rtvec * Perlin::perlin_generate()
{
    rtvec * p = new rtvec[256];
    for (int i = 0; i < 256; ++i)
        p[i] = rtvec(-1 + 2 * lvgm::rand01(), -1 + 2 * lvgm::rand01(), -1 + 2 * lvgm::rand01()).ret_unitization();
    return p;
}

且看上面这段代码， -1 + 2*lvgm::rand01()，返回的区间为-1~1

inline rtvar Perlin::noise(const rtvec& p)const
{
    int i = floor(p.x());
    int j = floor(p.y());
    int k = floor(p.z());
    rtvar u = p.x() - i;
    rtvar v = p.y() - j;
    rtvar w = p.z() - k;

    rtvec list[2][2][2];
    for (int a = 0; a < 2; ++a)
        for (int b = 0; b < 2; ++b)
            for (int c = 0; c < 2; ++c)
            {
                list[a][b][c] = _randomvalue[_perm_x[(i + a) & 255], _perm_y[(j + b) & 255], _perm_z[(k + c) & 255]];
#ifdef listtest
                if (list[a][b][c].x() < 0)stds cout << "list.x < 0 " << stds endl;
                if (list[a][b][c].y() < 0)stds cout << "list.y < 0 " << stds endl;
                if (list[a][b][c].z() < 0)stds cout << "list.z < 0 " << stds endl;
#endif
            }
    return perlin_interp(list, u, v, w);

上述测试部分可能会输出信息，因为list中有负值，然后Perlin向量插值就可能会是负值

rtvar Perlin::perlin_interp(rtvec list[2][2][2], rtvar u, rtvar v, rtvar w)
{
    rtvar uu = u*u*(3 - 2 * u);
    rtvar vv = v*v*(3 - 2 * v);
    rtvar ww = w*w*(3 - 2 * w);

    rtvar accumulate = 0;
    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < 2; ++j)
            for (int k = 0; k < 2; ++k)
            {
                rtvec weight(u - i, v - j, w - k);
                accumulate +=
                    (i*uu + (1 - i) * (1 - uu))*
                    (j*vv + (1 - j) * (1 - vv))*
                    (k*ww + (1 - k) * (1 - ww))*
                    lvgm::dot(list[i][j][k], weight);
#ifdef accumulatetest
                if (accumulate < 0)stds cout << "accumulate < 0 " << stds endl;
#endif
            }
    return (accumulate);
}

****************************** 为什么是“错”的 ***************************************

如果noise返回一个负值，那么

rtvec noise_texture::value(rtvar u, rtvar v, const rtvec& p)const
    {
    return rtvec(1., 1., 1.) *_noise.noise(p);
    }

它返回的就是一个负值

bool lambertian::scatter(const ray& rIn, const hitInfo& info, rtvec& attenuation, ray& scattered)const
    {
    rtvec target = info._p + info._n + lvgm::random_unit_sphere();
    scattered = ray{ info._p, target - info._p };
    attenuation = _albedo->value(0.,0.,info._p);
    return true;
    }

scatter传出去的attenuation就是负值

主函数中

错误信息会输出成功，lerp函数返回含有负值的向量

gamma校正负值开根号为出现无穷

你的图像文件数据读取会报错！

****************************** 插曲结束 ***************************************

那么如果把随机生成函数改为

rtvec * Perlin::perlin_generate()
{
    rtvec * p = new rtvec[256];
    for (int i = 0; i < 256; ++i)
        p[i] = rtvec(abs(-1 + 2 * lvgm::rand01()), abs(-1 + 2 * lvgm::rand01()), abs(-1 + 2 * lvgm::rand01())).ret_unitization();
    return p;
}

还不行，因为noise会返回负值，那么我们把Perlin插值的返回值改为正值即可

rtvar Perlin::perlin_interp(rtvec list[2][2][2], rtvar u, rtvar v, rtvar w)
{
    rtvar uu = u*u*(3 - 2 * u);
    rtvar vv = v*v*(3 - 2 * v);
    rtvar ww = w*w*(3 - 2 * w);

    rtvar accumulate = 0;
    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < 2; ++j)
            for (int k = 0; k < 2; ++k)
            {
                rtvec weight(u - i, v - j, w - k);
                accumulate +=
                    (i*uu + (1 - i) * (1 - uu))*
                    (j*vv + (1 - j) * (1 - vv))*
                    (k*ww + (1 - k) * (1 - ww))*
                    lvgm::dot(list[i][j][k], weight);
#ifdef accumulatetest
                if (accumulate < 0)stds cout << "accumulate < 0 " << stds endl;
#endif
            }
    return abs(accumulate);        //!!!
}

那么我们的图片将是这个样子的

如果我们不改动随机数生成器，只保证noise函数最后的返回值为正值

那么也是上面那个图

改动间还得到了如下图：

上面两个图是因为noise函数中list的值每次取得都和z有关，所以造成了上述线条现象

不小心重新抄写的时候将^写成了逗号，不过改为^也是错，因为不管怎么选择下标，该数组中的元素值始终都是-1~1

真正的解法是value取值的时候对noise的返回值做处理

下面是Perlin.hpp

/// Perlin.hpp

// -----------------------------------------------------
// [author]        lv
// [begin ]        2019.1
// [brief ]        the Perlin-class for the ray-tracing project
//                from the 《ray tracing the next week》
// -----------------------------------------------------


#pragma once

namespace rt
{
class Perlin
    {
public:
    inline rtvar noise(const rtvec& p)const;

    inline rtvar turb(const rtvec& p, int depth) const;

    inline rtvec* randomvalue()const { return _randomvalue; }

    inline int* perm_x()const { return _perm_x; }

    inline int* perm_y()const { return _perm_y; }

    inline int* perm_z()const { return _perm_z; }

public:

    static rtvec * perlin_generate();

    static void permute(int * p, int n);

    static int * perlin_generate_perm();

    static rtvar perlin_interp(rtvec list[2][2][2], rtvar u, rtvar v, rtvar w);

private:
    static rtvec * _randomvalue;

    static int * _perm_x;

    static int * _perm_y;

    static int * _perm_z;
    };




rtvec * Perlin::_randomvalue = Perlin::perlin_generate();

int * Perlin::_perm_x = Perlin::perlin_generate_perm();

int * Perlin::_perm_y = Perlin::perlin_generate_perm();

int * Perlin::_perm_z = Perlin::perlin_generate_perm();

rtvec * Perlin::perlin_generate()
    {
    rtvec * p = new rtvec[256];
    for (int i = 0; i < 256; ++i)
        p[i] = rtvec(-1 + 2 * lvgm::rand01(), -1 + 2 * lvgm::rand01(), -1 + 2 * lvgm::rand01()).ret_unitization();
    return p;
    }

int* Perlin::perlin_generate_perm()
    {
    int * p = new int[256];
    for (int i = 0; i < 256; ++i)    p[i] = i;
    permute(p, 256);
    return p;
    }

void Perlin::permute(int* p, int n)
    {
    for (int i = n - 1; i; i--)
        {
        int tar = int(lvgm::rand01() * (i + 1));
        stds swap(p[i], p[tar]);
        }
    }

rtvar Perlin::turb(const rtvec& p, int depth = 7) const 
    {
    rtvar accumulate = 0;
    rtvec t = p;
    rtvar weight = 1.0;
    for (int i = 0; i < depth; i++) 
        {
        accumulate += weight*noise(t);
        weight *= 0.5;
        t *= 2;
        }
    return abs(accumulate);
    }

inline rtvar Perlin::noise(const rtvec& p)const
    {
    int i = floor(p.x());
    int j = floor(p.y());
    int k = floor(p.z());
    rtvar u = p.x() - i;
    rtvar v = p.y() - j;
    rtvar w = p.z() - k;

    rtvec list[2][2][2];
    for (int a = 0; a < 2; ++a)
        for (int b = 0; b < 2; ++b)
            for (int c = 0; c < 2; ++c)
                {
                list[a][b][c] = _randomvalue[_perm_x[(i + a) & 255] ^ _perm_y[(j + b) & 255] ^ _perm_z[(k + c) & 255]];
#ifdef listtest
                if (list[a][b][c].x() < 0)stds cout << "list.x < 0 " << stds endl;
                if (list[a][b][c].y() < 0)stds cout << "list.y < 0 " << stds endl;
                if (list[a][b][c].z() < 0)stds cout << "list.z < 0 " << stds endl;
#endif
                }
    return perlin_interp(list, u, v, w);
    }

rtvar Perlin::perlin_interp(rtvec list[2][2][2], rtvar u, rtvar v, rtvar w)
    {
#ifdef uvwtest
    if (u < 0)stds cout << "u < 0 " << stds endl;
    if (v < 0)stds cout << "v < 0 " << stds endl;
    if (w < 0)stds cout << "w < 0 " << stds endl;
    if (u > 1)stds cout << "u > 1 " << stds endl;
    if (v > 1)stds cout << "v > 1 " << stds endl;
    if (w > 1)stds cout << "w > 1 " << stds endl;
#endif
    rtvar uu = u*u*(3 - 2 * u);
    rtvar vv = u*v*(3 - 2 * v);
    rtvar ww = u*w*(3 - 2 * w);

    rtvar accumulate = 0;
    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < 2; ++j)
            for (int k = 0; k < 2; ++k)
                {
                rtvec weight(u - i, v - j, w - k);
                accumulate +=
                    (i*uu + (1 - i) * (1 - uu))*
                    (j*vv + (1 - j) * (1 - vv))*
                    (k*ww + (1 - k) * (1 - ww))*
                    lvgm::dot(list[i][j][k], weight);
#ifdef accumulatetest
                if (accumulate < 0)stds cout << "accumulate < 0 " << stds endl;
#endif
                }
    return accumulate;        
    }

}