Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· OpenAIAi2 WildChat-4.8M (AI2)

用python实现2d simplex noise

  1. User

    用python实现2d simplex noise

  2. Assistant

    生成2D Simplex噪声,可以使用噪声生成库noise来实现。如果尚未安装,请运行以下代码以安装该库:

    pip install noise
    

    然后,可以使用以下代码创建一个简单的2D Simplex噪声实现:

    import numpy as np
    import matplotlib.pyplot as plt
    from noise import snoise2
    
    def generate_simplex_noise(size_x, size_y, octaves=1, persistence=0.5, lacunarity=2.0, scale=10.0):
        noise_array = np.zeros((size_x, size_y))
        for x in range(size_x):
            for y in range(size_y):
                noise_value = snoise2(x / scale, y / scale,
                                      octaves=octaves,
                                      persistence=persistence,
                                      lacunarity=lacunarity)
                noise_array[x][y] = noise_value
    
        return noise_array
    
    def main():
        size_x = 128
        size_y = 128
        octaves = 5
        persistence = 0.5
        lacunarity = 2.0
        scale = 10.0
    
        noise = generate_simplex_noise(size_x, size_y, octaves, persistence, lacunarity, scale)
    
        plt.imshow(noise, cmap='gray', origin='lower')
        plt.colorbar()
        plt.show()
    
    if __name__ == "__main__":
        main()
    

    这将生成一个128x128的2D Simplex噪声,并将其可视化显示。解释一下参数:

    • octaves: 表示噪声生成器的迭代次数。更多的迭代次数会产生更详细的噪声。
    • persistence: 控制每迭代一次细节明暗程度。较低的值将产生较少的详细信息,较高的值将增加更高频细节的强度。
    • lacunarity: 此参数影响频率在每次迭代时的增长量。
    • scale: 控制生成的噪声的缩放比例。较大的缩放值将使噪声看起来更分散,而较小的值会使其更密集。
  3. User

    我不想使用noise库

  4. Assistant

    当然可以。以下是一个不使用noise库实现2D Simplex噪声的版本。

    import math
    import numpy as np
    import matplotlib.pyplot as plt
    
    def dot_prod(g, x, y):
        return g[0]*x + g[1]*y
    
    # Simplex 噪声梯度向量
    gradients = np.array([[1,1],[-1,1],[1,-1],[-1,-1],
                         [1,0],[-1,0],[0,1],[0,-1]])
    
    # 快速floor函数
    def fast_floor(x):
        return math.floor(x) if x > 0 else math.floor(x - 1)
    
    # 2维插值函数
    def interpolate(v0, v1, t):
        return (1.0 - t) * v0 + t * v1
    
    # 与 simplex 格网相连的单位距离
    F2 = 0.5 * (math.sqrt(3.0) - 1.0)
    G2 = (3.0 - math.sqrt(3.0)) / 6.0
    
    def noise2d(x, y):
    
        s = (x + y) * F2
        i = fast_floor(x + s)
        j = fast_floor(y + s)
    
        t = (i + j) * G2
        X0 = i - t
        Y0 = j - t
        x0 = x - X0
        y0 = y - Y0
    
        if x0 > y0:
            i1 = 1
            j1 = 0
        else:
            i1 = 0
            j1 = 1
        
        x1 = x0 - i1 + G2
        y1 = y0 - j1 + G2
        x2 = x0 - 1.0 + 2.0 * G2
        y2 = y0 - 1.0 + 2.0 * G2
    
        ii = i & 255
        jj = j & 255
    
        gi0 = gradients[ii + jj] % 8
        gi1 = gradients[ii + i1 + jj + j1] % 8
        gi2 = gradients[ii + 1 + jj + 1] % 8
    
        t0 = 0.5 - x0**2 - y0**2
        if t0 < 0:
            n0 = 0.0
        else:
            t0 *= t0
            n0 = t0 * t0 * dot_prod(gradients[gi0], x0, y0)
    
        t1 = 0.5 - x1**2 - y1**2
        if t1 < 0:
            n1 = 0.0
        else:
            t1 *= t1
            n1 = t1 * t1 * dot_prod(gradients[gi1], x1, y1)
    
        t2 = 0.5 - x2**2 - y2**2
        if t2 < 0:
            n2 = 0.0
        else:
            t2 *= t2
            n2 = t2 * t2 * dot_prod(gradients[gi2], x2, y2)
    
        return 70.0 * (n0 + n1 + n2)
    
    def generate_simplex_noise(size_x, size_y, scale=10.0):
        noise_array = np.zeros((size_x, size_y))
    
        for x in range(size_x):
            for y in range(size_y):
                noise_value = noise2d(x / scale, y / scale)
                noise_array[x][y] = noise_value
    
        return noise_array
    
    def main():
        size_x = 128
        size_y = 128
        scale = 10.0
    
        noise = generate_simplex_noise(size_x, size_y, scale)
    
        plt.imshow(noise, cmap='gray', origin='lower')
        plt.colorbar()
        plt.show()
    
    if __name__ == "__main__":
        main()
    

    这个版本使用了一个基于梯度的实现,没有依赖noise库,尽管显示了2D Simplex噪声。