Wie erzeugt man kachelbares Perlin-Rauschen?

Verbunden:

• Einfache Geräuschentwicklung
• Grundlegendes zu Perlin-Rauschen

Ich möchte kachelbares Perlin-Rauschen erzeugen. Ich arbeite von Paul Bourkes PerlinNoise*() Funktionen aus, die so aussehen:

// alpha is the "division factor" (how much to damp subsequent octaves with (usually 2))
// beta is the factor that multiplies your "jump" into the noise (usually 2)
// n is the number of "octaves" to add in
double PerlinNoise2D(double x,double y,double alpha,double beta,int n)
{
   int i;
   double val,sum = 0;
   double p[2],scale = 1;

   p[0] = x;
   p[1] = y;
   for (i=0;i<n;i++) {
      val = noise2(p);
      sum += val / scale;
      scale *= alpha;
      p[0] *= beta;
      p[1] *= beta;
   }
   return(sum);
}

Verwenden Sie Code wie:

real val = PerlinNoise2D( x,y, 2, 2, 12 ) ; // test

return val*val*skyColor + 2*val*(1-val)*gray + (1-val)*(1-val)*cloudColor ;

Gibt Himmel wie

Welches ist nicht kachelbar.

Die Pixelwerte sind 0 -> 256 (Breite und Höhe) und Pixel (0,0) verwendet (x, y) = (0,0) und Pixel (256,256) verwendet (x, y) = (1,1).

Wie kann ich es fliesbar machen?

Es gibt zwei Teile, um fBm-Rauschen wie dieses nahtlos zu kacheln. Zunächst müssen Sie die Perlin-Rauschfunktion selbst kachelbar machen. Hier ist ein Python-Code für eine einfache Perlin-Rauschfunktion, die mit einer beliebigen Periode bis zu 256 arbeitet (Sie können sie beliebig erweitern, indem Sie den ersten Abschnitt ändern):

import random
import math
from PIL import Image

perm = range(256)
random.shuffle(perm)
perm += perm
dirs = [(math.cos(a * 2.0 * math.pi / 256),
         math.sin(a * 2.0 * math.pi / 256))
         for a in range(256)]

def noise(x, y, per):
    def surflet(gridX, gridY):
        distX, distY = abs(x-gridX), abs(y-gridY)
        polyX = 1 - 6*distX**5 + 15*distX**4 - 10*distX**3
        polyY = 1 - 6*distY**5 + 15*distY**4 - 10*distY**3
        hashed = perm[perm[int(gridX)%per] + int(gridY)%per]
        grad = (x-gridX)*dirs[hashed][0] + (y-gridY)*dirs[hashed][1]
        return polyX * polyY * grad
    intX, intY = int(x), int(y)
    return (surflet(intX+0, intY+0) + surflet(intX+1, intY+0) +
            surflet(intX+0, intY+1) + surflet(intX+1, intY+1))

Perlin-Rauschen wird aus einer Summe kleiner "Surflets" erzeugt, die das Produkt eines zufällig orientierten Gradienten und einer trennbaren Polynom-Falloff-Funktion sind. Dies ergibt einen positiven Bereich (gelb) und einen negativen Bereich (blau).

Die Surflets haben eine Ausdehnung von 2 × 2 und sind auf die ganzzahligen Gitterpunkte zentriert, sodass der Wert des Perlin-Rauschens an jedem Punkt im Raum durch Summieren der Surflets an den Ecken der Zelle, die sie einnehmen, erzeugt wird.

Wenn Sie die Verlaufsrichtungen mit einer bestimmten Periode umbrechen lassen, wird das Rauschen selbst nahtlos mit derselben Periode umbrochen. Aus diesem Grund nimmt der obige Code das Gitterkoordinatenmodul für die Periode, bevor es durch die Permutationstabelle gehasht wird.

Der andere Schritt ist, dass Sie beim Summieren der Oktaven die Periode mit der Frequenz der Oktave skalieren möchten. Im Wesentlichen soll jede Oktave das gesamte gerade Bild einmal und nicht mehrmals kacheln:

def fBm(x, y, per, octs):
    val = 0
    for o in range(octs):
        val += 0.5**o * noise(x*2**o, y*2**o, per*2**o)
    return val

Füge das zusammen und du bekommst so etwas:

size, freq, octs, data = 128, 1/32.0, 5, []
for y in range(size):
    for x in range(size):
        data.append(fBm(x*freq, y*freq, int(size*freq), octs))
im = Image.new("L", (size, size))
im.putdata(data, 128, 128)
im.save("noise.png")

Wie Sie sehen können, funktioniert dies in der Tat nahtlos:

Mit einigen kleinen Optimierungen und Farbzuordnungen ist hier ein Wolkenbild, das 2x2 gekachelt ist:

Hoffe das hilft!

Hier ist eine ziemlich clevere Methode, die 4D Perlin-Rauschen verwendet.

Ordnen Sie im Allgemeinen die X-Koordinate Ihres Pixels einem 2D-Kreis und die Y-Koordinate Ihres Pixels einem zweiten 2D-Kreis zu und platzieren Sie diese beiden Kreise orthogonal zueinander im 4D-Raum. Die resultierende Textur ist kachelbar, weist keine offensichtlichen Verzerrungen auf und wiederholt sich nicht wie eine gespiegelte Textur.

Kopieren und Einfügen von Code aus dem Artikel:

for x=0,bufferwidth-1,1 do
    for y=0,bufferheight-1,1 do
        local s=x/bufferwidth
        local t=y/bufferheight
        local dx=x2-x1
        local dy=y2-y1

        local nx=x1+cos(s*2*pi)*dx/(2*pi)
        local ny=y1+cos(t*2*pi)*dy/(2*pi)
        local nz=x1+sin(s*2*pi)*dx/(2*pi)
        local nw=y1+sin(t*2*pi)*dy/(2*pi)

        buffer:set(x,y,Noise4D(nx,ny,nz,nw))
    end
end

OK ich habe es. Die Antwort ist, in einem Torus in 3D-Rauschen zu laufen und daraus eine 2D-Textur zu erzeugen.

Code:

Color Sky( double x, double y, double z )
{
  // Calling PerlinNoise3( x,y,z ),
  // x, y, z _Must be_ between 0 and 1
  // for this to tile correctly
  double c=4, a=1; // torus parameters (controlling size)
  double xt = (c+a*cos(2*PI*y))*cos(2*PI*x);
  double yt = (c+a*cos(2*PI*y))*sin(2*PI*x);
  double zt = a*sin(2*PI*y);
  double val = PerlinNoise3D( xt,yt,zt, 1.5, 2, 12 ) ; // torus

  return val*val*cloudWhite + 2*val*(1-val)*gray + (1-val)*(1-val)*skyBlue ;
}

Ergebnisse:

Einmal:

Und gekachelt:

Ein einfacher Weg, den ich mir vorstellen kann, wäre, die Ausgabe der Rauschfunktion zu nehmen und sie in ein Bild zu spiegeln / zu spiegeln, das doppelt so groß ist. Es ist schwer zu erklären, daher hier ein Bild:

In diesem Fall ist es ziemlich offensichtlich, was Sie getan haben, als Sie sich das anschauten. Ich kann mir zwei Möglichkeiten vorstellen, dies (möglicherweise :-)) zu lösen:

1. Sie könnten das größere Bild aufnehmen und dann etwas mehr Rauschen darüber erzeugen, aber (und ich bin mir nicht sicher, ob dies möglich ist) auf die Mitte fokussieren (damit die Ränder gleich bleiben). Es könnte den zusätzlichen Unterschied hinzufügen, der Ihr Gehirn denken lässt, dass es sich nicht nur um Spiegelbilder handelt.

2. (Ich bin mir auch nicht sicher, ob dies möglich ist.) Sie können versuchen, mit den Eingaben für die Rauschfunktion zu experimentieren, um das ursprüngliche Bild anders zu erzeugen. Sie müssten dies durch Ausprobieren tun, aber suchen Sie nach Funktionen, die Ihre Aufmerksamkeit auf sich ziehen, wenn Sie sie kacheln / spiegeln, und versuchen Sie dann, sie nicht zu generieren.

Hoffe das hilft.

Die erste Version dieser Antwort war tatsächlich falsch. Ich habe sie aktualisiert

Ein Verfahren verwenden I ist erfolgreich Lärm Domain gefliest. Mit anderen Worten, machen Sie Ihre noise2()Basisfunktion periodisch. Wenn noise2()periodisch und betaganzzahlig ist, hat das resultierende Rauschen die gleiche Periode wie noise2().

Wie können wir noise2()periodisch machen ? In den meisten Implementierungen verwendet diese Funktion eine Art Gitterrauschen. Das heißt, es werden Zufallszahlen an ganzzahligen Koordinaten abgerufen und interpoliert. Zum Beispiel:

function InterpolatedNoise_1D(float x)

  integer_X    = int(x)
  fractional_X = x - integer_X

  v1 = SmoothedNoise1(integer_X)
  v2 = SmoothedNoise1(integer_X + 1)

  return Interpolate(v1 , v2 , fractional_X)

end function

Diese Funktion kann trivial modifiziert werden, um mit einer ganzzahligen Periode periodisch zu werden. Fügen Sie einfach eine Zeile hinzu:

integer_X = integer_X % Period

vor der Berechnung v1und v2. Auf diese Weise werden Werte an ganzzahligen Koordinaten alle Periodeneinheiten wiederholt, und durch Interpolation wird sichergestellt, dass die resultierende Funktion reibungslos ist.

Beachten Sie jedoch, dass dies nur funktioniert, wenn die Periode größer als 1 ist. Wenn Sie dies also für die Erstellung nahtloser Texturen verwenden möchten, müssen Sie ein Quadrat aus Periode x Periode und nicht 1x1 abtasten.

Eine andere Alternative besteht darin, mit libnoise-Bibliotheken Rauschen zu erzeugen. Sie können nahtlos über eine theoretisch unendliche Menge an Raum Rauschen erzeugen.

Schauen Sie sich Folgendes an: http://libnoise.sourceforge.net/tutorials/tutorial3.html#tile

Es gibt auch einen XNA-Port für das oben Genannte unter : http://bigblackblock.com/tools/libnoisexna

Wenn Sie am Ende den XNA-Port verwenden, können Sie Folgendes tun:

Perlin perlin = new Perlin();
perlin.Frequency = 0.5f;                //height
perlin.Lacunarity = 2f;                 //frequency increase between octaves
perlin.OctaveCount = 5;                 //Number of passes
perlin.Persistence = 0.45f;             //
perlin.Quality = QualityMode.High;
perlin.Seed = 8;

//Create our 2d map
Noise2D _map = new Noise2D(CHUNKSIZE_WIDTH, CHUNKSIZE_HEIGHT, perlin);

//Get a section
_map.GeneratePlanar(left, right, top, down);

GeneratePlanar ist die Funktion, die aufgerufen wird, um die Abschnitte in jeder Richtung abzurufen, die sich nahtlos mit den übrigen Texturen verbinden.

Natürlich ist diese Methode teurer als nur eine einzige Textur, die über mehrere Oberflächen hinweg verwendet werden kann. Wenn Sie nach zufälligen kachelbaren Texturen suchen, könnte dies für Sie von Interesse sein.

Obwohl es hier einige Antworten gibt, die funktionieren würden, sind die meisten kompliziert, langsam und problematisch.

Alles, was Sie wirklich tun müssen, ist die Verwendung einer Funktion zur periodischen Geräuscherzeugung. Das ist es!

Eine exzellente Public Domain-Implementierung basierend auf Perlins "fortgeschrittenem" Rauschalgorithmus finden Sie hier . Die Funktion, die Sie benötigen, ist pnoise2. Der Code wurde von Stefan Gustavson geschrieben, der genau zu diesem Thema hier einen spitzen Kommentar abgegeben hat und wie andere den falschen Ansatz gewählt haben. Hör Gustavson zu, er weiß wovon er spricht.

In Bezug auf die verschiedenen sphärischen Projektionen haben einige angedeutet: Nun, sie funktionieren im Wesentlichen (langsam), aber sie erzeugen auch eine 2D-Textur, die eine abgeflachte Kugel ist, so dass die Kanten stärker verdichtet würden, was wahrscheinlich einen unerwünschten Effekt hervorruft. Wenn Sie beabsichtigen, Ihre 2D-Textur auf eine Kugel zu projizieren, ist dies natürlich der richtige Weg, aber danach wurde nicht gefragt.

Hier ist eine viel einfachere Möglichkeit, gekachelte Geräusche zu erzeugen:

Sie verwenden einen modularen Umgriff für jede Skala des Geräusches. Diese passen sich den Rändern des Bereichs an, unabhängig davon, welche Frequenzskala Sie verwenden. Sie müssen also nur normales 2D-Rauschen verwenden, das viel schneller ist. Hier ist der Live-WebGL-Code, der unter ShaderToy zu finden ist: https://www.shadertoy.com/view/4dlGW2

Die drei obersten Funktionen erledigen die gesamte Arbeit, und fBM wird ein Vektor x / y in einem Bereich von 0,0 bis 1,0 übergeben.

// Tileable noise, for creating useful textures. By David Hoskins, Sept. 2013.
// It can be extrapolated to other types of randomised texture.

#define SHOW_TILING
#define TILES 2.0

//----------------------------------------------------------------------------------------
float Hash(in vec2 p, in float scale)
{
    // This is tiling part, adjusts with the scale...
    p = mod(p, scale);
    return fract(sin(dot(p, vec2(35.6898, 24.3563))) * 353753.373453);
}

//----------------------------------------------------------------------------------------
float Noise(in vec2 x, in float scale )
{
    x *= scale;

    vec2 p = floor(x);
    vec2 f = fract(x);
    f = f*f*(3.0-2.0*f);
    //f = (1.0-cos(f*3.1415927)) * .5;
    float res = mix(mix(Hash(p,                  scale),
        Hash(p + vec2(1.0, 0.0), scale), f.x),
        mix(Hash(p + vec2(0.0, 1.0), scale),
        Hash(p + vec2(1.0, 1.0), scale), f.x), f.y);
    return res;
}

//----------------------------------------------------------------------------------------
float fBm(in vec2 p)
{
    float f = 0.4;
    // Change starting scale to any integer value...
    float scale = 14.0;
    float amp = 0.55;
    for (int i = 0; i < 8; i++)
    {
        f += Noise(p, scale) * amp;
        amp *= -.65;
        // Scale must be multiplied by an integer value...
        scale *= 2.0;
    }
    return f;
}

//----------------------------------------------------------------------------------------
void main(void)
{
    vec2 uv = gl_FragCoord.xy / iResolution.xy;

#ifdef SHOW_TILING
    uv *= TILES;
#endif

    // Do the noise cloud (fractal Brownian motion)
    float bri = fBm(uv);

    bri = min(bri * bri, 1.0); // ...cranked up the contrast for no reason.
    vec3 col = vec3(bri);

#ifdef SHOW_TILING
    vec2 pixel = (TILES / iResolution.xy);
    // Flash borders...
    if (uv.x > pixel.x && uv.y > pixel.y                                        // Not first pixel
    && (fract(uv.x) < pixel.x || fract(uv.y) < pixel.y) // Is it on a border?
    && mod(iGlobalTime-2.0, 4.0) < 2.0)                 // Flash every 2 seconds
    {
        col = vec3(1.0, 1.0, 0.0);
    }
#endif
    gl_FragColor = vec4(col,1.0);
}

Ich hatte einige nicht schlechte Ergebnisse bei der Interpolation in der Nähe der Kanten der Kachel (kantenumwickelt), aber es hängt davon ab, welchen Effekt Sie erzielen möchten und welche genauen Rauschparameter vorliegen. Funktioniert hervorragend bei etwas verschwommenen Geräuschen, nicht so gut bei spitzen / feinkörnigen.

Ich habe diesen Thread auf der Suche nach einer Antwort auf ein ähnliches Problem überprüft und dann vom Entwickler dieses Python-Codes eine saubere und kompakte Lösung zur Erzeugung von fraktalem Rauschen aus Perlin / Simplex-Rauschen erhalten. Der aktualisierte Code ist in dieser (abgeschlossenen) Ausgabe enthalten und kann fortgesetzt werden, indem die Farbverläufe für die rechte Seite des "Generators" mit denen auf der linken Seite (und für oben und unten) gleichgesetzt werden, z. B. in

# Gradients
angles = 2*np.pi*np.random.rand(res[0]+1, res[1]+1)
gradients = np.dstack((np.cos(angles), np.sin(angles)))
# Make the noise tileable
gradients[-1,:] = gradients[0,:]
gradients[:,-1] = gradients[:,0]

Scheint eine elegante und saubere Lösung zu sein, ich vermeide es, den gesamten Code hier zu kopieren (da es nicht meine eigene Lösung ist), aber sie ist unter dem oben angegebenen Link verfügbar. Hoffe, dass dies für jemanden nützlich sein kann, der ein kachelbares fraktales 2D-Bild wie das von mir benötigte ohne Artefakte oder Verzerrungen erstellen möchte.