[Python] J'ai écrit de force une courte fonction de génération de bruit parlin dans Numpy.

introduction

** ・ Qu'est-ce que le bruit pearlin ** Le bruit Parlin est un bruit facile à utiliser (tel que la génération de terrain aléatoire) avec une continuité et un désordre raisonnables. D'autres ont écrit les détails, donc je vais simplement présenter le code ici.

La fonction que j'ai écrite

perlin.py

#Importer la bibliothèque
import numpy as np
import matplotlib.pyplot as plt

#Enfants qui produisent une interpolation linéaire et une continuité
def fade(t):return 6*t**5-15*t**4+10*t**3
def lerp(a,b,t):return a+fade(t)*(b-a)

#Corps
def perlin(r,seed=np.random.randint(0,100)):
    np.random.seed(seed)

    ri = np.floor(r).astype(int) #Partie entière, utilisée comme index
    ri[0] -= ri[0].min()         #
    ri[1] -= ri[1].min()         #Prêt à utiliser comme index
    rf = np.array(r) % 1         #Partie décimale
    g = 2 * np.random.rand(ri[0].max()+2,ri[1].max()+2,2) - 1 #Gradient de points de grille
    e = np.array([[[[0,0],[0,1],[1,0],[1,1]]]])                       #quatre coins
    er = (np.array([rf]).transpose(2,3,0,1) - e).reshape(r.shape[1],r.shape[2],4,1,2) #Vecteur de position vu de chaque point des quatre coins
    gr = np.r_["3,4,0",g[ri[0],ri[1]],g[ri[0],ri[1]+1],g[ri[0]+1,ri[1]],g[ri[0]+1,ri[1]+1]].transpose(0,1,3,2).reshape(r.shape[1],r.shape[2],4,2,1) #Transformé en une forme permettant de calculer le produit intérieur en collectant les dégradés des quatre coins avec le tri fantaisie familier
    p = (er@gr).reshape(r.shape[1],r.shape[2],4).transpose(2,0,1) #Calcul interne du produit avec gradient pour tous les points
    
    return lerp(lerp(p[0],p[2],rf[0]),lerp(p[1],p[3],rf[0]),rf[1]) #Interpoler et revenir

Calcul / tracé

perlin.py

N = 512
y = np.zeros((N,N))
for i in np.random.rand(1):         #Le bruit Parlin semble montrer son vrai potentiel lorsque vous changez la fréquence et empilez plusieurs feuilles, alors bouclez et ajoutez (s'il vous plaît autant que vous le souhaitez)
    x = np.linspace(0,8*i,N)
    r = np.array(np.meshgrid(x,x))
    y += perlin(r)                  #forme de meshgrid(2,N,N)Passer à côté

plt.imshow(y)
plt.show()

Résultat:

Autre tracé 3D et version de dimension étendue

Résumé

Ce code est écrit parce que je ne veux pas utiliser de boucles. En chemin, un tenseur à 5 dimensions sort, mais ça fait du bien de pouvoir écrire clairement.