Comprensione del rumore di Perlin

Sto giocando con Perlin Noise dopo aver lavorato con Diamond Square. Ho seguito l' implementazione di Hugo Elias che fondamentalmente crea una serie di funzioni con x, y come input per lanciare ogni valore di coordinata.

Il mio codice PHP è qui :

Ho due domande:

Come si usa l'algoritmo per generare una mappa di altezza in un array? Non l'ho capito appieno e ho appena portato su PHP lo pseudocodice, ma facendo l'ultima funzione (map_perlined) dopo aver letto da qualche parte che l'algoritmo "magicamente" ti dà valori di transizione per ogni punto x, y dato (apparentemente, senza dover leggere il suo valori adiacenti), ottengo questo solo quando uso come funzione casualemt_rand(-100,100)/100;

E questo quando si utilizza il crittografico: 1.0-(($n*($n*$n*15731+789221)+1376312589)&0x7fffffff)/1073741824.0;(che, a proposito, può essere implementato "così com'è" in PHP?):

Quindi, riassumendo, tre domande:

1. Il mio codice è corretto?
2. La funzione casuale può essere trasferita su PHP come descritto nel codice? Non genera errori, ma i risultati non ci sono.
3. Come uso effettivamente l'algoritmo?

AGGIORNARE

Ok, ha creato una porta PHP del codice mostrato nel documento di Gustavson e, come ha detto un altro programmatore, genera solo un'ottava. Hai qualche altro sito / documento / guida utile su come usarlo con i concetti di ottave multiple, ampiezza, frequenza, ecc. Per controllare la funzione del rumore? Sulla carta di Gustavson mostra solo i risultati, non la reale implementazione dell'algoritmo, forse mi sto perdendo qualcosa?

AGGIORNAMENTO 2
@NATHAN

Ho fatto qualcosa del tipo:

$persistence = 0.5;

for ($j = 0; $j < $size; $j++) {
    for ($i = 0; $i < $size; $i++) {

        for ($o = 0; $o < 8; $o++) {
            $frequency = pow(2,$o);
            $amplitude = pow($persistence, $o);
            $value += SimplexNoise($i*$frequency, $j * $frequency) * $amplitude;
            }

            //$value = SimplexNoise($i, $j) + 0.5 * SimplexNoise($i, $j) + 0.25 * SimplexNoise($i, $j);
            $this->mapArray[$i][$j] = new Cell($value);

E dopo aver normalizzato i valori su 0..1, ottengo una mappa di altezza piuttosto noiosa come:

Come si esegue il seeding della mappa? Forse quello che devo implementare è la versione 3d con il terzo valore un'altezza casuale? Ma in tal caso, dovrei scoprire di prendere in considerazione i valori del vicino, che finirei con qualcosa come un algoritmo a diamante quadrato, esattamente ciò che non voglio fare.

AGGIORNAMENTO 3

Più lavoro Perlin. Devo ancora trovare un modo per guidare il rumore verso i miei risultati. Controlla queste ottave e il risultato finale:

Ottava da I a IV

Riassunto

Ogni ottava è praticamente la stessa. Controlla il codice:

$persistence = 0.5;

    for ($j = 0; $j < $size; $j++) {
      for ($i = 0; $i < $size; $i++) {
        $value = 0;

        for ($o = 0; $o < 4; $o++) {
          $frequency = pow(2,$o);
          $amplitude = pow($persistence, $o);
          $value += improved_noise($i*$frequency, $j*$frequency, 0.5)*$amplitude;

        }
        $this->map[$i][$j] = new Cell($value);

I risultati sono normalizzati. Cosa useresti avrebbe una forte influenza nello sviluppo del rumore? Vedo esempi in cui il cambiamento dell'ampiezza dà superfici morbide o ruvide, ma anche se do un'ampiezza enorme, vedo poca differenza.

Quello che hai implementato non è il rumore di Perlin. Non sono sicuro del perché Hugo Elias lo dica, ma è confuso. Ecco l'implementazione di riferimento di Ken Perlin. In realtà non chiama alcun generatore di numeri casuali esterno, ma utilizza una funzione hash integrata per produrre vettori di gradiente pseudocasuali.

Si noti inoltre che il rumore di Perlin consiste in una sola ottava. Riassumendo più ottave (istanze ridimensionate della funzione noise), come suggerisce Hugo Elias, è una tecnica utile, ma non fa parte del rumore di Perlin. Ciò che si ottiene facendo questo è chiamato rumore frattale, a volte "rumore browniano frattale" (a causa della presunta somiglianza con il moto browniano).

Se vuoi capire geometricamente cosa sta facendo l'algoritmo, prova questo documento . Riguarda un diverso tipo di rumore chiamato "rumore simplex", ma include anche una spiegazione del rumore classico Perlin. Per inciso, anche il rumore simplex è stato inventato da Perlin e dovrebbe essere un miglioramento rispetto al suo rumore classico, quindi potresti provare a implementarlo anche se sei interessato a giocare con le funzioni del rumore.

Questo è un malinteso comune. Ciò che Hugo Elias chiama "Perlin" noise è in realtà un rumore frattale o rosa. Per capire meglio cos'è il rumore di Perlin, puoi leggere l'articolo di Perlin collegato nella risposta di Nathan Reed o i documenti di libnoise (c'è lo stesso errore lì: il rumore di Perlin è ciò che chiamano rumore di gradiente) o i documenti di CoherentNoise .

Ora, per rispondere effettivamente alla tua domanda: non hai ottenuto il risultato atteso perché la frequenza del rumore è troppo alta. Le tue frequenze iniziano con 1 e aumentano, il che significa che ogni pixel nella mappa risultante ha un valore casuale. Per vedere la struttura più fine della mappa, è necessario "ingrandire" il rumore. In realtà non parlo PHP, ma suppongo che il codice dovrebbe apparire così:

$arrayMap[$i][$j] = PerlinNoise_2D($i/$width, $j/$height, $p, $octaves);

Cioè, "allunghi" un periodo di rumore sull'intera mappa. Certo, puoi usare altri coefficienti: prova solo diversi coefficienti, vedi cosa succede.