Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

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

林-兮 2019-01-19 12:00:00 阅读数:336 评论数:0 点赞数:0 收藏数:0

 

 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;
}
}
Perlin.hpp

 

  以及noise_texture.hpp中的value函数,如下:

方可解决noise中返回为负的情况,_scale 为 5 的时候做出的图如下:

 

 

 

 同样,我们可以将光线追踪提高图片质量的惯用伎俩——采样,用在噪声值生成上面,即:使用具有多个相加频率的复合噪声。 这通常称为turbulence

 

用turb函数来代替noise函数,编者在turb返回的时候取了绝对值,而noise中的负值任由不管,不知为何。。

 

得到如下图:

 

既然,编者已经将turb返回值取了绝对值,我们大可试一下之前的value函数

 

_scale 为 5 时候

 

 

看着有点密集,和书上的不太像,把_scale调为3,得到如下图,看着差不多了

 

程序纹理的入门是大理石纹理, 基本思想是使颜色与正弦函数成比例,并使用turbulence来调整相位,能使条纹起伏

 

 y = sin(wx + φ)

_scale就是w值,我实在调不出来书上的纹理

 

 我把_scale的值调成6.3,结果如下:

 

 _scale 值越大,图像上的正弦曲线波动幅度越小

如果谁调整出来书上的_scale值了,请于下方评论区留言

 

我们不妨把value函数中的turb改为原来的noise

 

 

则得到下面这幅图

可以看到比较明显的格块状,所以turb还是好一点

 

今天就到这儿了,感谢您的阅读,生活愉快~

 

版权声明
本文为[林-兮]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/lv-anchoret/p/10291292.html

飞链云3D数字艺术品
30万现金开奖等你来领