Perlin噪声算法
摘要
解释Perlin噪声算法,涵盖噪声的概念、相干噪声以及在程序化生成中实现噪声函数的基础。
暂无内容
查看缓存全文
缓存时间: 2026/07/22 17:23
# Perlin 噪声算法 来源:https://blog.jaysmito.dev/blog/02-perlins-noise-algorithm
## 什么是噪声?
如果你尝试了解程序化生成相关的任何内容,你一定会遇到 **噪声**!那么,它到底是什么?简单来说,噪声就是随机值的集合。老实说,核心上噪声就是如此,但你可以猜到,事情并没有那么简单。更技术性地讲,噪声是一个函数。一个接受 N 个参数,并根据某些规则(规则取决于我们所讨论的算法)返回值的函数。
根据参数的数量,我们可以将噪声分类为一维、二维、三维等。而它返回值的范围也取决于我们所讨论的算法。
每种噪声都有多种用途,但在我看来,实现算法时最容易处理的是 **二维** 噪声,因为它非常容易可视化。
**如何可视化?** 通过 *纹理*(图像)!一旦我们为二维实现了算法,通常可以将其推广到一维、三维等(至少大多数时候如此)。
好的,那么我们如何使用噪声函数生成纹理呢?以下是一些伪代码:
```
for(int i = 0 ; i < image.height ; i++) {
for(int j = 0 ; j < image.width ; j++) {
float n = noise( (float)j / image.width , (float)i / image.height );
n = n / NOISE_MAX; // 将噪声计算到 [0, 1] 范围
image.SetPixel(j, i, n, n, n); // 在像素 (j, i) 处设置 (R, G, B) 值
}
}
```
现在,让我们看看发生了什么。我们遍历所有像素,并将噪声函数的输出值(以 **x 和 y** 坐标为输入)赋给它们。你可能会想,为什么我要将 **x 和 y** 坐标除以宽度和高度呢?这样做是为了将它们归一化,映射到 [0, 1) 范围(因为 `i`、`j` 从 `0` 开始,只到 `width - 1`、`height - 1`,所以一端是开的)。**为什么我们要这么做?** 我现在还不能回答,所以我们先盲目地跟着做。将来当我们讨论对这些噪声函数应用变换时,我们会看到如何变换这些参数来得到我们想要的噪声。但那是以后的事情了。
好的,那么噪声函数本身呢?我们试试使用[上一篇文章中的 `rand()` 函数](https://blog.jaysmito.dev/blog/01-generating-random-numbers)来看看会怎样。
```c
float noise(float x, float y) {
return rand(x + y);
}
```
注意:*我们这里使用 x 和 y 坐标作为种子。*
输出:
new.png
很酷吧?不酷?嗯,可以说它本身并不是很有趣,对吧?**我的意思是什么?** 一切都是非常随机的,我们分辨不出任何特定模式或特征。
那么,什么才算有趣呢?让我们看看:
new.png
这看起来更有趣一点,对吧?现在你可以分辨出一些特征或模式,但本质上它还是很随机,对吧?这被称为 **相干噪声**。它是我们之前使用 `rand()`(一个 **伪随机** 噪声函数)的噪声函数的平滑版本。
相干噪声函数有一些基本特性:
- 传入相同的输入值总是返回相同的输出值(几乎所有噪声算法都如此)
- 输入值的小变化会导致输出值的小变化
- 输入值的大变化会导致输出值的随机变化
## Perlin 噪声算法
有很多算法可以生成相干噪声,我们将逐一介绍它们。但毫无疑问,最著名的噪声算法是 **Perlin 噪声**。
引用 Wikipedia 的一些历史:
> Ken Perlin 在 1983 年开发了 Perlin 噪声,原因是他对当时计算机生成图像(CGI)的“机器感”感到沮丧。他于 1985 年在 SIGGRAPH 的一篇题为《An Image Synthesizer》的论文中正式描述了他的发现。他在动画公司 Mathematical Applications Group (MAGI) 为迪士尼的计算机动画科幻电影《Tron》(1982)工作后开发了它。1997 年,Perlin 因创建该算法获得了奥斯卡技术成就奖。
注意:*本文中 Perlin 噪声算法的实现来自**这里** (https://cs.nyu.edu/~perlin/doc/oscar.html#noise)*
好的,开始进入算法。我们知道噪声函数的输入是二维平面上的两个数。
从上图可以看出,二维平面上的每个点都位于一个正方形内,正方形的角坐标是离该点坐标最近的整数。我们可以很容易地得到正方形的四个角坐标:
假设我们的点是 P=(x,y)。那么正方形的角坐标为:
- P0 = (floor(x), floor(y))
- P1 = (floor(x), floor(y)+1)
- P2 = (floor(x)+1, floor(y))
- P3 = (floor(x)+1, floor(y)+1)
Perlin 的算法指出,对于这四个点中的每一个,都有一个预先计算的随机 **单位向量**。然后我们计算从这四个点到当前输入点 ***P*** 的向量。现在我们有了四对向量(一个是预先计算的随机向量,另一个是我们计算的向量)。然后我们需要计算这四对向量的点积。接着我们需要混合这四个点积值,然后就得到了噪声!
这信息量很大,所以让我们在实现代码时逐一处理。
首先是预先计算的向量。你可能会问,整数有无穷多个,我们怎么能预先计算呢?对吧?这引出了 Perlin 算法最大的缺点之一。由于我们无法预先计算无穷多个值,原始算法中做的是预先计算一组 256 个随机 **单位向量** 和一个 256 个随机排列的数组,称为 **置换表**。然后利用这些为每个整数点选择一个随机向量。因此,你可以猜到,噪声将在 256 之后开始重复。现在我们先不担心这个,而是尝试建立我们自己的预计算向量集。
让我们声明一个全局数组来存储这些向量。
```c
static Vector2 gradients[B + B + 2];
static int permutation[B + B + 2];
```
注意:Perlin 最初称这些为**梯度**和**置换表**。
那么这里的 B 是什么?查看原始实现,我们发现 `#define B 0x100`。这意味着什么?如果你一直认真跟着,或者对十六进制比较熟悉,你就能看出 B 就是 `256`,即排列的数量。这里我们计算了 512 个梯度,比原来的 256 多了一倍,以防止缓冲区溢出。
计算它们的代码如下:
```c
for (int i = 0 ; i < B ; i++) {
permutation[i] = i;
gradients[i] = Vector2.Random();
gradients[i] = Vector2.Normalize(gradients[i]);
}
for (int i = 0, j = 0 ; i < B ; i++) {
int k = permutation[i];
permutation[i] = permutation[j = random() % B];
permutation[j] = k;
}
for (i = 0 ; i < B + 2 ; i++) {
permutation[B + i] = permutation[i];
gradients[B + i] = gradients[i];
}
```
这里发生了很多事。我们逐步分解。
首先,我们从 `0` 到 `B`(`256`)循环,将置换表索引 `i` 处的值设置为 `i` 本身。同时,将索引 `i` 处的梯度设置为一个随机二维向量,然后将其归一化。归一化意味着使向量成为单位向量(模长为 1.0 的向量)。
注意,此时我们的置换表值都等于它们的索引,这远非随机。所以我们需要随机化它。我们再次循环从 `0` 到 `B`(`256`),并将每个元素与数组中的一个随机元素交换。这是一种巧妙的方法,可以在不重复的情况下获得一个范围内(0-255)的随机元素数组。
如果你难以理解这行代码:
```c
permutation[i] = permutation[j = random() % B];
```
它所做的就是:首先使用某种伪随机数生成函数(比如我们上一篇文章讨论的 `rand()` 函数)生成一个随机数。然后计算该随机数模 B,将其包裹在 [0, B) 范围内。然后将该值赋给 `j`,以便稍后用它来交换索引 `j` 处的置换表值。
最后,我们将 [0, 256) 范围内的值复制到表的后半部分。
现在,主要部分是算法本身。我们慢慢来看。
```c
float rx0 = x - (int)x;
float rx1 = rx0 - 1.0f;
float ry0 = y - (int)y;
float ry1 = ry0 - 1.0f;
```
这里我们计算从边界正方形顶点到我们需要计算噪声的点的向量。
接下来,我们需要计算四个角点对应的四个随机向量。
```c
int bx0 = ((int)x) & 255;
int by0 = ((int)y) & 255;
int bx1 = (bx0 + 1) & 255;
int by1 = (by0 + 1) & 255;
```
这到底是什么?首先,我们计算点左下角的角点 `[bx0, by0]`。之前我展示了一些使用 floor 函数的公式,但 Perlin 使用了一些巧妙的数学技巧。让我们试着理解它。
首先,将点坐标转换为整数,这相当于 `floor(x)` 的效果。然后这里有一个数学小技巧。注意:
x % 2^n = x & 2^(n-1)
所以我们可以说,这里真正做的是:
```c
int bx0 = ((int)x) % 256;
int by0 = ((int)y) % 256;
int bx1 = (bx0 + 1) % 256;
int by1 = (by0 + 1) % 256;
```
这个模运算确保 `bx0`、`bx1`、`by0`、`by1` 都在 [0, 256) 范围内。
接下来:
```c
int i = permutation[bx0];
int j = permutation[bx1];
int b00 = permutation[i + by0];
int b10 = permutation[j + by1];
int b01 = permutation[i + by0];
int b11 = permutation[j + by1];
```
这里我们基于 `x`、`y` 的值计算 4 个索引,用于从梯度表中采样随机向量。
**注意:** 如果你注意到了,`i`、`j` 在 [0, 256) 范围内,而 `by0`、`by1`、`bx0`、`bx1` 也在 [0, 256) 范围内。我们将它们相加后,值在 [0, 512) 范围内。这就是为什么我们将 `permutation` 数组的大小设为 `B + B + 2`。
接下来:
```c
float u = Vector2.Dot(gradients[b00], Vector2(rx0, ry0));
float v = Vector2.Dot(gradients[b10], Vector2(rx1, ry0));
float a = Lerp(rx0, u, v);
```
这里我们计算了采样的梯度与从我们要计算噪声的点到角点的向量之间的点积。
**注意:** 这里你也可以自由地做其他事情。稍后我们会尝试一些不同的东西。
然后我们使用 `rx0` 作为因子对这两个值(u, v)进行插值。`Lerp` 表示线性插值。它看起来像这样:
```c
float Lerp(float t, float a, float b) {
return ( a + t * (b - a) );
}
```
现在我们需要对另外两组向量做同样的操作。
```c
u = Vector2.Dot(gradients[b01], Vector2(rx0, ry1));
v = Vector2.Dot(gradients[b11], Vector2(rx1, ry1));
float b = Lerp(rx0, u, v);
```
这是关于在 X 轴上插值两个点积。我们类似地在 Y 轴上重复同样的操作并返回结果。
```c
return Lerp(ry0, a, b);
```
好的!我们已经实现了 Perlin 噪声。至少大部分完成了。
现在,在我们尝试查看结果之前,需要对创建图像的函数做一些修改!
```c
for(int i = 0 ; i < image.height ; i++) {
for(int j = 0 ; j < image.width ; j++) {
float n = noise( 3.0f * (float)j / image.width , 3.0f * (float)i / image.height );
n = n * 0.5f + 0.5f; // 将噪声计算到 [0, 1] 范围
image.SetPixel(j, i, n, n, n); // 在像素 (j, i) 处设置 (R, G, B) 值
}
}
```
再次强调,暂时忽略我们为什么这样做。我会专门写一篇文章来讨论这个问题。如果你好奇,可以搜索关于坐标缩放和偏移的内容。
现在跳过这个,让我们看看效果如何。
嗯,还行。但我在实现中跳过了某个特定部分——平滑曲线。你看,我们直接使用 `rx0` 和 `ry0` 进行了插值。但 Perlin 在他的原始实现中,将这些值通过一条曲线处理。曲线是:
y = x^2 (3 - 2x)
它看起来像这样:
现在我们只需要关注 [0, 1] 范围,因为我们的 `rx0` 和 `ry0` 总是在这个范围内。我们可以看到在这个范围内,这个函数是一条平滑的 S 形曲线。
现在,这改变了我们的代码:
```c
float a = Lerp(SCurve(rx0), u, v);
float b = Lerp(SCurve(rx0), u, v);
return Lerp(SCurve(ry0), a, b);
```
让我们看看效果如何。
嗯,这就是原始的 Perlin 噪声!
但是,等等!这和上面示例中看到的并不一样,对吧?确实不一样。你看,我们在这里讨论的算法是 Ken Perlin 给出的 **原始** 算法。但在给出这个算法的几年后,他进行了一些改进,比如改变了平滑曲线、梯度的计算方式等。而这些将是我们下一篇文章的主题。
感谢阅读!
相似文章
梯度噪声的隐藏优雅
对Perlin噪声的详细解释及其在ClojureScript中的实现,包括代码片段和移动水丝的动画。
地形扩散:一种基于扩散的Perlin噪声继任者,用于无限、实时地形生成
地形扩散引入了基于扩散的Perlin噪声继任者,采用新颖的InfiniteDiffusion算法,以常数时间随机访问生成逼真、无缝且无限的程序化世界。
什么是随机生成?
本文探讨了计算机中的伪随机数生成,重点聚焦于线性同余生成器(LCG)及其质量可视化。文章还提及了 Cloudflare 的熔岩灯等熵源,并作为基于属性的测试的前导内容。
用于去噪生成的优化框架
本文将不以噪声为条件的去噪生成重新表述为对固定对数密度目标的梯度上升,证明了其在参考流形附近的收敛性、有限分辨率下的覆盖性,以及一种既能避免记忆训练样本又能保持多样性的机制,并通过实验验证了生成过程的可控性和鲁棒性。
@docmilanfar: 我非常喜欢我们最近关于"Geometry of Noise"的论文的解释性文章 arXiv:2602.18428
本文提供了理论解释,说明为什么扩散模型可以在没有显式噪声水平条件的情况下生成干净的样本,将其归因于高维几何,并分析为什么某些模型参数化成功而其他模型崩溃。