如何制作更平滑的 Perlin 噪声发生器？
How to make a smoother Perlin noise generator?
我正在尝试使用 Perlin 噪声发生器来制作地图的图块，但我注意到我的噪声太尖锐了，我的意思是，它有太多的高程，没有平坦的地方，而且它们不不像山脉、岛屿、湖泊或任何东西；它们看起来太随机了，而且有很多峰值。
在问题的末尾，需要进行一些更改才能修复它。
问题的重要代码是：
1D:
def Noise(self, x): # I wrote this noise function but it seems too random
random.seed(x)
number = random.random()
if number < 0.5:
final = 0 - number * 2
elif number > 0.5:
final = number * 2
return final
def Noise(self, x): # I found this noise function on the internet
x = (x<<13) ^ x
return ( 1.0 - ( (x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
2D:
def Noise(self, x, y): # I wrote this noise function but it seems too random
n = x + y
random.seed(n)
number = random.random()
if number < 0.5:
final = 0 - number * 2
elif number > 0.5:
final = number * 2
return final
def Noise(self, x, y): # I found this noise function on the internet
n = x + y * 57
n = (n<<13) ^ n
return ( 1.0 - ( (x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
我在代码中留下了 1D 和 2D Perlin 噪声，因为也许有人对此感兴趣：
（我花了很长时间才找到一些代码，所以我想有人会很高兴在这里找到一个例子）。
您不需要 Matplotlib 或 NumPy 来制造噪音；我只是用它们来制作图表并更好地查看结果。
import random
import matplotlib.pyplot as plt # To make graphs
from mpl_toolkits.mplot3d import Axes3D # To make 3D graphs
import numpy as np # To make graphs
class D(): # Base of classes D1 and D2
def Cubic_Interpolate(self, v0, v1, v2, v3, x):
P = (v3 - v2) - (v0 - v1)
Q = (v0 - v1) - P
R = v2 - v0
S = v1
return P * x**3 + Q * x**2 + R * x + S
class D1(D):
def __init__(self, lenght, octaves):
self.result = self.Perlin(lenght, octaves)
def Noise(self, x): # I wrote this noise function but it seems too random
random.seed(x)
number = random.random()
if number < 0.5:
final = 0 - number * 2
elif number > 0.5:
final = number * 2
return final
def Noise(self, x): # I found this noise function on the internet
x = (x<<13) ^ x
return ( 1.0 - ( (x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
def Perlin(self, lenght, octaves):
result = []
for x in range(lenght):
value = 0
for y in range(octaves):
frequency = 2 ** y
amplitude = 0.25 ** y
value += self.Interpolate_Noise(x * frequency) * amplitude
result.append(value)
print(f"{x} / {lenght} ({x/lenght*100:.2f}%): {round(x/lenght*10) * '#'} {(10-round(x/lenght*10)) * ' '}. Remaining {lenght-x}.") # I don't use `os.system('cls')` because it slow down the code.
return result
def Smooth_Noise(self, x):
return self.Noise(x) / 2 + self.Noise(x-1) / 4 + self.Noise(x+1) / 4
def Interpolate_Noise(self, x):
round_x = round(x)
frac_x = x - round_x
v0 = self.Smooth_Noise(round_x - 1)
v1 = self.Smooth_Noise(round_x)
v2 = self.Smooth_Noise(round_x + 1)
v3 = self.Smooth_Noise(round_x + 2)
return self.Cubic_Interpolate(v0, v1, v2, v3, frac_x)
def graph(self, *args):
plt.plot(np.array(self.result), '-', label = "Line")
for x in args:
plt.axhline(y=x, color='r', linestyle='-')
plt.xlabel('X')
plt.ylabel('Y')
plt.title("Simple Plot")
plt.legend()
plt.show()
class D2(D):
def __init__(self, lenght, octaves = 1):
self.lenght_axes = round(lenght ** 0.5)
self.lenght = self.lenght_axes ** 2
self.result = self.Perlin(self.lenght, octaves)
def Noise(self, x, y): # I wrote this noise function but it seems too random
n = x + y
random.seed(n)
number = random.random()
if number < 0.5:
final = 0 - number * 2
elif number > 0.5:
final = number * 2
return final
def Noise(self, x, y): # I found this noise function on the internet
n = x + y * 57
n = (n<<13) ^ n
return ( 1.0 - ( (x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
def Smooth_Noise(self, x, y):
corners = (self.Noise(x - 1, y - 1) + self.Noise(x + 1, y - 1) + self.Noise(x - 1, y + 1) + self.Noise(x + 1, y + 1) ) / 16
sides = (self.Noise(x - 1, y) + self.Noise(x + 1, y) + self.Noise(x, y - 1) + self.Noise(x, y + 1) ) / 8
center = self.Noise(x, y) / 4
return corners + sides + center
def Interpolate_Noise(self, x, y):
round_x = round(x)
frac_x = x - round_x
round_y = round(y)
frac_y = y - round_y
v11 = self.Smooth_Noise(round_x - 1, round_y - 1)
v12 = self.Smooth_Noise(round_x , round_y - 1)
v13 = self.Smooth_Noise(round_x + 1, round_y - 1)
v14 = self.Smooth_Noise(round_x + 2, round_y - 1)
i1 = self.Cubic_Interpolate(v11, v12, v13, v14, frac_x)
v21 = self.Smooth_Noise(round_x - 1, round_y)
v22 = self.Smooth_Noise(round_x , round_y)
v23 = self.Smooth_Noise(round_x + 1, round_y)
v24 = self.Smooth_Noise(round_x + 2, round_y)
i2 = self.Cubic_Interpolate(v21, v22, v23, v24, frac_x)
v31 = self.Smooth_Noise(round_x - 1, round_y + 1)
v32 = self.Smooth_Noise(round_x , round_y + 1)
v33 = self.Smooth_Noise(round_x + 1, round_y + 1)
v34 = self.Smooth_Noise(round_x + 2, round_y + 1)
i3 = self.Cubic_Interpolate(v31, v32, v33, v34, frac_x)
v41 = self.Smooth_Noise(round_x - 1, round_y + 2)
v42 = self.Smooth_Noise(round_x , round_y + 2)
v43 = self.Smooth_Noise(round_x + 1, round_y + 2)
v44 = self.Smooth_Noise(round_x + 2, round_y + 2)
i4 = self.Cubic_Interpolate(v41, v42, v43, v44, frac_x)
return self.Cubic_Interpolate(i1, i2, i3, i4, frac_y)
def Perlin(self, lenght, octaves):
result = []
for x in range(lenght):
value = 0
for y in range(octaves):
frequency = 2 ** y
amplitude = 0.25 ** y
value += self.Interpolate_Noise(x * frequency, x * frequency) * amplitude
result.append(value)
print(f"{x} / {lenght} ({x/lenght*100:.2f}%): {round(x/lenght*10) * '#'} {(10-round(x/lenght*10)) * ' '}. Remaining {lenght-x}.") # I don't use `os.system('cls')` because it slow down the code.
return result
def graph(self, color = 'viridis'):
# Other colors: https://matplotlib.org/examples/color/colormaps_reference.html
fig = plt.figure()
Z = np.array(self.result).reshape(self.lenght_axes, self.lenght_axes)
ax = fig.add_subplot(1, 2, 1, projection='3d')
X = np.arange(self.lenght_axes)
Y = np.arange(self.lenght_axes)
X, Y = np.meshgrid(X, Y)
d3 = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=color, linewidth=0, antialiased=False)
fig.colorbar(d3)
ax = fig.add_subplot(1, 2, 2)
d2 = ax.imshow(Z, cmap=color, interpolation='none')
fig.colorbar(d2)
plt.show()
问题是输出似乎不适合地图。
使用以下方法查看此输出：
test = D2(1000, 3)
test.graph()
我正在寻找更流畅的东西。
也许在 2D 噪声中很难注意到我在说什么，但在 1D 中就容易多了：
test = D1(1000, 3)
test.graph()
来自互联网的噪声函数的峰值略小且频率较低，但仍然太多。我正在寻找更流畅的东西。
可能是这样的：
或者这样：
P.S: 我根据 this pseudocode.
做了这个
编辑：
皮卡莱克:
即使值很低，它也有峰值，没有曲线或 smooth/flat 线。
geza：解决方案
感谢 我找到了问题的解决方案：
def Perlin(self, lenght_axes, octaves, zoom = 0.01, amplitude_base = 0.5):
result = []
for y in range(lenght_axes):
line = []
for x in range(lenght_axes):
value = 0
for o in range(octaves):
frequency = 2 ** o
amplitude = amplitude_base ** o
value += self.Interpolate_Noise(x * frequency * zoom, y * frequency * zoom) * amplitude
line.append(value)
result.append(line)
print(f"{y} / {lenght_axes} ({y/lenght_axes*100:.2f}%): {round(y/lenght_axes*20) * '#'} {(20-round(y/lenght_axes*20)) * ' '}. Remaining {lenght_axes-y}.")
return result
其他修改是：
Z = np.array(self.result) 而不是图形函数中的这个 Z = np.array(self.result).reshape(self.lenght_axes, self.lenght_axes)。- 在
round_x 和 round_y 变量的 Interpolate_Noise 函数中使用 math.floor()（记住 import math）而不是 round()。
- 将
Noise（第二个）中的 return 行修改为 return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0) 。
D2(10000, 10)
现在唯一奇怪的是山（黄色）总是在同一个地方附近，但我认为这是改变 Noise 函数中的数字的问题。
您需要实施更积极的平滑算法。最好的方法是使用矩阵卷积。它的工作方式是，您有一个矩阵，我们将其称为 "Kernel" 应用于网格中的每个单元格，从而创建一个新的转换数据集。一个示例内核可能是：
0.1 0.1 0.1
0.1 0.2 0.1
0.1 0.1 0.1
假设您有这样的网格：
2 4 1 3 5
3 5 1 2 3
4 9 2 1 2
3 4 9 5 2
1 1 3 6 7
假设我们想将内核应用到最中心的 2，我们将切割出内核形状的网格并将每个单元格与其对应的内核单元格相乘：
. . . . .
. 5 1 2 . 0.1 0.1 0.1 0.5 0.1 0.2
. 9 2 1 . x 0.1 0.2 0.1 = 0.9 0.4 0.1
. 4 9 5 . 0.1 0.1 0.1 0.4 0.9 0.5
. . . . .
然后我们可以将所有这些值相加以获得单元格的新值 0.5+0.1+0.2+0.9+0.4+0.1+0.4+0.9+0.5 = 4，然后我们在新数据集上填写 space：
? ? ? ? ?
? ? ? ? ?
? ? 4 ? ?
? ? ? ? ?
? ? ? ? ?
...如您所想，我们必须在网格中为彼此重复此操作 space 以填充我们的新数据集。完成后，我们丢弃旧数据并使用这个新网格作为我们的数据集。
这样做的好处是您可以使用大量内核来执行非常大的平滑操作。例如，您可以使用 5x5 或 9x9 大小的内核，这将使您的噪声更加平滑。
另外请注意，需要构建内核，使其所有单元格的总和为 1，否则您将无法实现质量守恒（可以这么说；例如，如果总和大于 1，则您的峰值会变得更高，你的数据的平均值会更高）。 5x5 矩阵的示例为：
0.010 0.024 0.050 0.024 0.010
0.024 0.050 0.062 0.050 0.024
0.050 0.062 0.120 0.062 0.050
0.024 0.050 0.062 0.050 0.024
0.010 0.024 0.050 0.024 0.010
确保这种质量的一种方法是简单地对矩阵进行归一化；将每个单元格除以所有单元格的总和。例如：
1 4 16 4 1 0.002808989 0.011235955 0.04494382 0.011235955 0.002808989
4 16 32 16 4 0.011235955 0.04494382 0.08988764 0.04494382 0.011235955
16 32 64 32 16 (sum = 356) --> 0.04494382 0.08988764 0.179775281 0.08988764 0.04494382
4 16 32 16 4 0.011235955 0.04494382 0.08988764 0.04494382 0.011235955
1 4 16 4 1 0.002808989 0.011235955 0.04494382 0.011235955 0.002808989
我在您的代码中发现了这些错误：
- 您需要将
Interpolate_Noise 参数乘以 "zoom" 到映射中（例如，将 x 乘以 0.01）。如果你在 1D 情况下这样做，你会发现生成的函数已经好得多了
- 将八度数从 3 增加到更大（3 个八度不会产生太多细节）
- 使用振幅 0.5^octave，而不是 0.25^octave（但是你可以玩这个参数，所以 0.25 本身并不坏，但它没有提供太多细节）
- 对于2D的情况，你需要有2个外部循环（一个用于水平，一个用于垂直。当然，你仍然需要有八度循环）。所以你需要 "index" 水平和垂直位置的噪声，而不仅仅是
x 和 x.
- 完全删除平滑。 Perlin 噪声不需要它。
- 2D噪声函数有一个错误：它在return表达式
中使用x而不是n
- 在三次插值时，您使用
round 而不是 math.floor。
这是我的一个答案，带有类似 Perlin 的简单 (C++) 实现（这不是正确的 perlin）噪声：
您可以使用简单的算法使噪声更平滑 -> f(n)=(f(n-1) + f(n+1))/2
不知道为什么，但它正在工作
我正在尝试使用 Perlin 噪声发生器来制作地图的图块，但我注意到我的噪声太尖锐了，我的意思是，它有太多的高程，没有平坦的地方，而且它们不不像山脉、岛屿、湖泊或任何东西；它们看起来太随机了，而且有很多峰值。
在问题的末尾，需要进行一些更改才能修复它。
问题的重要代码是：
1D:
def Noise(self, x): # I wrote this noise function but it seems too random
random.seed(x)
number = random.random()
if number < 0.5:
final = 0 - number * 2
elif number > 0.5:
final = number * 2
return final
def Noise(self, x): # I found this noise function on the internet
x = (x<<13) ^ x
return ( 1.0 - ( (x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
2D:
def Noise(self, x, y): # I wrote this noise function but it seems too random
n = x + y
random.seed(n)
number = random.random()
if number < 0.5:
final = 0 - number * 2
elif number > 0.5:
final = number * 2
return final
def Noise(self, x, y): # I found this noise function on the internet
n = x + y * 57
n = (n<<13) ^ n
return ( 1.0 - ( (x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
我在代码中留下了 1D 和 2D Perlin 噪声，因为也许有人对此感兴趣：
（我花了很长时间才找到一些代码，所以我想有人会很高兴在这里找到一个例子）。
您不需要 Matplotlib 或 NumPy 来制造噪音；我只是用它们来制作图表并更好地查看结果。
import random
import matplotlib.pyplot as plt # To make graphs
from mpl_toolkits.mplot3d import Axes3D # To make 3D graphs
import numpy as np # To make graphs
class D(): # Base of classes D1 and D2
def Cubic_Interpolate(self, v0, v1, v2, v3, x):
P = (v3 - v2) - (v0 - v1)
Q = (v0 - v1) - P
R = v2 - v0
S = v1
return P * x**3 + Q * x**2 + R * x + S
class D1(D):
def __init__(self, lenght, octaves):
self.result = self.Perlin(lenght, octaves)
def Noise(self, x): # I wrote this noise function but it seems too random
random.seed(x)
number = random.random()
if number < 0.5:
final = 0 - number * 2
elif number > 0.5:
final = number * 2
return final
def Noise(self, x): # I found this noise function on the internet
x = (x<<13) ^ x
return ( 1.0 - ( (x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
def Perlin(self, lenght, octaves):
result = []
for x in range(lenght):
value = 0
for y in range(octaves):
frequency = 2 ** y
amplitude = 0.25 ** y
value += self.Interpolate_Noise(x * frequency) * amplitude
result.append(value)
print(f"{x} / {lenght} ({x/lenght*100:.2f}%): {round(x/lenght*10) * '#'} {(10-round(x/lenght*10)) * ' '}. Remaining {lenght-x}.") # I don't use `os.system('cls')` because it slow down the code.
return result
def Smooth_Noise(self, x):
return self.Noise(x) / 2 + self.Noise(x-1) / 4 + self.Noise(x+1) / 4
def Interpolate_Noise(self, x):
round_x = round(x)
frac_x = x - round_x
v0 = self.Smooth_Noise(round_x - 1)
v1 = self.Smooth_Noise(round_x)
v2 = self.Smooth_Noise(round_x + 1)
v3 = self.Smooth_Noise(round_x + 2)
return self.Cubic_Interpolate(v0, v1, v2, v3, frac_x)
def graph(self, *args):
plt.plot(np.array(self.result), '-', label = "Line")
for x in args:
plt.axhline(y=x, color='r', linestyle='-')
plt.xlabel('X')
plt.ylabel('Y')
plt.title("Simple Plot")
plt.legend()
plt.show()
class D2(D):
def __init__(self, lenght, octaves = 1):
self.lenght_axes = round(lenght ** 0.5)
self.lenght = self.lenght_axes ** 2
self.result = self.Perlin(self.lenght, octaves)
def Noise(self, x, y): # I wrote this noise function but it seems too random
n = x + y
random.seed(n)
number = random.random()
if number < 0.5:
final = 0 - number * 2
elif number > 0.5:
final = number * 2
return final
def Noise(self, x, y): # I found this noise function on the internet
n = x + y * 57
n = (n<<13) ^ n
return ( 1.0 - ( (x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)
def Smooth_Noise(self, x, y):
corners = (self.Noise(x - 1, y - 1) + self.Noise(x + 1, y - 1) + self.Noise(x - 1, y + 1) + self.Noise(x + 1, y + 1) ) / 16
sides = (self.Noise(x - 1, y) + self.Noise(x + 1, y) + self.Noise(x, y - 1) + self.Noise(x, y + 1) ) / 8
center = self.Noise(x, y) / 4
return corners + sides + center
def Interpolate_Noise(self, x, y):
round_x = round(x)
frac_x = x - round_x
round_y = round(y)
frac_y = y - round_y
v11 = self.Smooth_Noise(round_x - 1, round_y - 1)
v12 = self.Smooth_Noise(round_x , round_y - 1)
v13 = self.Smooth_Noise(round_x + 1, round_y - 1)
v14 = self.Smooth_Noise(round_x + 2, round_y - 1)
i1 = self.Cubic_Interpolate(v11, v12, v13, v14, frac_x)
v21 = self.Smooth_Noise(round_x - 1, round_y)
v22 = self.Smooth_Noise(round_x , round_y)
v23 = self.Smooth_Noise(round_x + 1, round_y)
v24 = self.Smooth_Noise(round_x + 2, round_y)
i2 = self.Cubic_Interpolate(v21, v22, v23, v24, frac_x)
v31 = self.Smooth_Noise(round_x - 1, round_y + 1)
v32 = self.Smooth_Noise(round_x , round_y + 1)
v33 = self.Smooth_Noise(round_x + 1, round_y + 1)
v34 = self.Smooth_Noise(round_x + 2, round_y + 1)
i3 = self.Cubic_Interpolate(v31, v32, v33, v34, frac_x)
v41 = self.Smooth_Noise(round_x - 1, round_y + 2)
v42 = self.Smooth_Noise(round_x , round_y + 2)
v43 = self.Smooth_Noise(round_x + 1, round_y + 2)
v44 = self.Smooth_Noise(round_x + 2, round_y + 2)
i4 = self.Cubic_Interpolate(v41, v42, v43, v44, frac_x)
return self.Cubic_Interpolate(i1, i2, i3, i4, frac_y)
def Perlin(self, lenght, octaves):
result = []
for x in range(lenght):
value = 0
for y in range(octaves):
frequency = 2 ** y
amplitude = 0.25 ** y
value += self.Interpolate_Noise(x * frequency, x * frequency) * amplitude
result.append(value)
print(f"{x} / {lenght} ({x/lenght*100:.2f}%): {round(x/lenght*10) * '#'} {(10-round(x/lenght*10)) * ' '}. Remaining {lenght-x}.") # I don't use `os.system('cls')` because it slow down the code.
return result
def graph(self, color = 'viridis'):
# Other colors: https://matplotlib.org/examples/color/colormaps_reference.html
fig = plt.figure()
Z = np.array(self.result).reshape(self.lenght_axes, self.lenght_axes)
ax = fig.add_subplot(1, 2, 1, projection='3d')
X = np.arange(self.lenght_axes)
Y = np.arange(self.lenght_axes)
X, Y = np.meshgrid(X, Y)
d3 = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=color, linewidth=0, antialiased=False)
fig.colorbar(d3)
ax = fig.add_subplot(1, 2, 2)
d2 = ax.imshow(Z, cmap=color, interpolation='none')
fig.colorbar(d2)
plt.show()
问题是输出似乎不适合地图。
使用以下方法查看此输出：
test = D2(1000, 3)
test.graph()
我正在寻找更流畅的东西。
也许在 2D 噪声中很难注意到我在说什么，但在 1D 中就容易多了：
test = D1(1000, 3)
test.graph()
来自互联网的噪声函数的峰值略小且频率较低，但仍然太多。我正在寻找更流畅的东西。
可能是这样的：
或者这样：
P.S: 我根据 this pseudocode.
做了这个编辑：
皮卡莱克:
即使值很低，它也有峰值，没有曲线或 smooth/flat 线。
geza：解决方案
感谢
def Perlin(self, lenght_axes, octaves, zoom = 0.01, amplitude_base = 0.5):
result = []
for y in range(lenght_axes):
line = []
for x in range(lenght_axes):
value = 0
for o in range(octaves):
frequency = 2 ** o
amplitude = amplitude_base ** o
value += self.Interpolate_Noise(x * frequency * zoom, y * frequency * zoom) * amplitude
line.append(value)
result.append(line)
print(f"{y} / {lenght_axes} ({y/lenght_axes*100:.2f}%): {round(y/lenght_axes*20) * '#'} {(20-round(y/lenght_axes*20)) * ' '}. Remaining {lenght_axes-y}.")
return result
其他修改是：
Z = np.array(self.result)而不是图形函数中的这个Z = np.array(self.result).reshape(self.lenght_axes, self.lenght_axes)。- 在
round_x和round_y变量的Interpolate_Noise函数中使用math.floor()（记住import math）而不是round()。 - 将
Noise（第二个）中的return行修改为return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0)。D2(10000, 10)Noise函数中的数字的问题。
您需要实施更积极的平滑算法。最好的方法是使用矩阵卷积。它的工作方式是，您有一个矩阵，我们将其称为 "Kernel" 应用于网格中的每个单元格，从而创建一个新的转换数据集。一个示例内核可能是：
0.1 0.1 0.1
0.1 0.2 0.1
0.1 0.1 0.1
假设您有这样的网格：
2 4 1 3 5
3 5 1 2 3
4 9 2 1 2
3 4 9 5 2
1 1 3 6 7
假设我们想将内核应用到最中心的 2，我们将切割出内核形状的网格并将每个单元格与其对应的内核单元格相乘：
. . . . .
. 5 1 2 . 0.1 0.1 0.1 0.5 0.1 0.2
. 9 2 1 . x 0.1 0.2 0.1 = 0.9 0.4 0.1
. 4 9 5 . 0.1 0.1 0.1 0.4 0.9 0.5
. . . . .
然后我们可以将所有这些值相加以获得单元格的新值 0.5+0.1+0.2+0.9+0.4+0.1+0.4+0.9+0.5 = 4，然后我们在新数据集上填写 space：
? ? ? ? ?
? ? ? ? ?
? ? 4 ? ?
? ? ? ? ?
? ? ? ? ?
...如您所想，我们必须在网格中为彼此重复此操作 space 以填充我们的新数据集。完成后，我们丢弃旧数据并使用这个新网格作为我们的数据集。
这样做的好处是您可以使用大量内核来执行非常大的平滑操作。例如，您可以使用 5x5 或 9x9 大小的内核，这将使您的噪声更加平滑。
另外请注意，需要构建内核，使其所有单元格的总和为 1，否则您将无法实现质量守恒（可以这么说；例如，如果总和大于 1，则您的峰值会变得更高，你的数据的平均值会更高）。 5x5 矩阵的示例为：
0.010 0.024 0.050 0.024 0.010
0.024 0.050 0.062 0.050 0.024
0.050 0.062 0.120 0.062 0.050
0.024 0.050 0.062 0.050 0.024
0.010 0.024 0.050 0.024 0.010
确保这种质量的一种方法是简单地对矩阵进行归一化；将每个单元格除以所有单元格的总和。例如：
1 4 16 4 1 0.002808989 0.011235955 0.04494382 0.011235955 0.002808989
4 16 32 16 4 0.011235955 0.04494382 0.08988764 0.04494382 0.011235955
16 32 64 32 16 (sum = 356) --> 0.04494382 0.08988764 0.179775281 0.08988764 0.04494382
4 16 32 16 4 0.011235955 0.04494382 0.08988764 0.04494382 0.011235955
1 4 16 4 1 0.002808989 0.011235955 0.04494382 0.011235955 0.002808989
我在您的代码中发现了这些错误：
- 您需要将
Interpolate_Noise参数乘以 "zoom" 到映射中（例如，将x乘以0.01）。如果你在 1D 情况下这样做，你会发现生成的函数已经好得多了 - 将八度数从 3 增加到更大（3 个八度不会产生太多细节）
- 使用振幅 0.5^octave，而不是 0.25^octave（但是你可以玩这个参数，所以 0.25 本身并不坏，但它没有提供太多细节）
- 对于2D的情况，你需要有2个外部循环（一个用于水平，一个用于垂直。当然，你仍然需要有八度循环）。所以你需要 "index" 水平和垂直位置的噪声，而不仅仅是
x和x. - 完全删除平滑。 Perlin 噪声不需要它。
- 2D噪声函数有一个错误：它在return表达式 中使用
- 在三次插值时，您使用
round而不是math.floor。
x而不是n
这是我的一个答案，带有类似 Perlin 的简单 (C++) 实现（这不是正确的 perlin）噪声：
您可以使用简单的算法使噪声更平滑 -> f(n)=(f(n-1) + f(n+1))/2
不知道为什么，但它正在工作