code:

---

function PerlinNoise_2D(float x, float y)
...
loop i from 0 to n

          frequency = 2i
          amplitude = pi

          total = total + InterpolatedNoisei(x * frequency, y * frequency) * amplitude

end of i loop
...

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Java code:

---

float p = 1f; // Persistenz, der Einfachheit halber 1

// der Einfachheit halber nur ein Durchgang (also nur eine Noise-Funktion)
for (int round=1; round<=1; round++)
{
    // Frequenz und Amplitude der Einfachheit halber 1
    int frequency = (int)Math.pow(2, round);
    float amplitude = (float)Math.pow(p, round);

    // Abstand zwischen den zu berechnenden Punkten, alle 
    // dazwischenliegenden werden interpoliert
    int offset = 1;

    // ein Bereich von 100x100 Pixeln in der Mitte eines schwarzen
    // Quadrates, Schrittweite = offset
    for (int x=20; x<=100; x+=offset)
    {
	for (int y=20; y<100; y+=offset)
	{
            // Noise-Wert des aktuellen Pixels berechnen
            float rand = getNoise(x*frequency, y*frequency) * amplitude;
	    
            // Farbe mit Hilfe des Noise-Wertes setzen und Pixel malen    
            g.setColor(new Color(Math.abs((int)(rand*125f)), Math.abs((int)(rand*125f)), Math.abs((int)(rand*255f))));
	    g.fillRect(x, y, 1, 1);

            // Wenn Schrittweite>1 => interpolieren aller Zwischenpixel
	    if ((offset > 1))
	    {
	        // Alle Zwischenpunkte interpolieren
		for (int j=1; j<offset; j++)
		{
		    // Y, aber nicht für ersten Durchlauf
		    if (y > 20)
		    {
                        // Noise-Wert des 2. Randpunktes bestimmen
			float randInt = getNoise(x*frequency, (y-offset)*frequency) * amplitude;
                        // interpolierte Noise-Wert, der 3. Parameter
                        // bestimmt sich aus 1/Schrittweit multipliziert
                        // mit dem aktuellen Durchlauf (also bei 
                        // Schrittweite 2 ergibt sich 0,5; bei 
                        // Schrittweite 3 ergeben sich 0,33 und 0,66 etc.)
			rand = interpolateCos(rand, randInt, j*(1f/(float)offset));
                        // Farbwert setzen und Pixel zeichnen
			g.setColor(new Color(Math.abs((int)(rand*125f)), Math.abs((int)(rand*125f)), Math.abs((int)(rand*255f))));
			g.fillRect(x, y-j, 1, 1);

                        // X, aber für alle y-offset
			if (x > 20)
			{
			    for (int k=1; k<offset; k++)
			    {
				randInt = getNoise((x-offset)*frequency, (y-k)*frequency) * amplitude;
				rand = interpolateCos(rand, randInt, (offset-j)*(1f/(float)offset));
				g.setColor(new Color(Math.abs((int)(rand*125f)), Math.abs((int)(rand*125f)), Math.abs((int)(rand*255f))));
				g.fillRect(x-j, y-k, 1, 1);
			    }
			}
		    }
		}
            }
	}
    }
}

---

Java code:

---

private float interpolateCos(float a, float b, float x)
{
    return (float)(((1+Math.cos(x*Math.PI))/2 ) * a + ( 1 - (1+Math.cos(x*Math.PI))/2 ) * b);
}

---

Java code:

---

private float getNoise(int x, int y) {
    int n = x + y * 57;
    n = (n << 13) ^ n;
    return 1.0f - ((float)( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff)) / (float)1073741824;
}

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Reth:
Hier noch die Interpolationsfunktion, die ist abgeschrieben:

Java code:

---

private float interpolateCos(float a, float b, float x)
{
    return (float)(((1+Math.cos(x*Math.PI))/2 ) * a + ( 1 - (1+Math.cos(x*Math.PI))/2 ) * b);
}

---

Das seltsame an dieser ist, dass laut diesem Beitrag hier:

Cosinus Interpolation

Die Funktion nur Werte zw. 0 und 1 zurückliefern sollte (was ich nachvollziehen konnte).
Ich bekomme aber bei negativen Eingaben (wenn die eingegebenen Noise-Werte negativ sind) auch negative Rückgabewerte! Das verstehe ich nun wiederum nicht!

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Irgendwie hat das Ganze mein Interesse geweckt
Ich versuch immer so Teilfragen zu beantworten.

Zitat:

---

Original von Reth:
Wie addiere ich denn pixelweise die Bilder auf?
Wenn ich die 3 Bilder habe und bei allen dreien (nach Interpolation) an einer Position ein Noise-Wert (meinetwegen grau auf schwarzem Hintergrund) ist, wie addiere ich die dann?
Mal rein von den Farbwerten her gesehen (wenn mein Maximum bei 255 liegt), was mach ich, wenn ich die 3 Grauwerte addiere (also Weißanteil) und dann bei >255 lande?

---

code:

---

Pixel(x,y)_Endbild=Pixel(x,y)_Bild1*2/3+Pixel(x,y)_Bild2*1/6+Pixel(x,y)_Bild3*1/6

---

code:

---

Pixel(x,y)_Endbild=(Pixel(x,y)_Bild1+Pixel(x,y)_Bild2+Pixel(x,y)_Bild3)/3

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Der_Wanderer:
Och Reth, ein bisschen anstengen solltest du dich schon. Und schreibe am besten alles von Grund auf selbst, dann verstehst du es am besten.

---

Danke für Deine Erklärung!

Aber genau das versuche ich ja! Ich dachte, dass kommt aus meinen Posts deutlich raus? Darum ja die grundsätzlichen Verständnisfragen und mein bisheriger Code. Ich sagte doch, dass ich die Funktionen nicht einfach nur abtippen, sondern verstehen will!

Was glaubst Du, was ich die letzten Tage stundenlang versucht habe (und davon einige Stunde mit dem Versuch verbracht habe, die mathematischen Grundlagen aufzufrischen/zu verstehen, v.a. für Interpolation - allerdings haben die gefundenen Artikel im Wiki und sonstwo eher zur Verzögerung beigetragen; so eine anschauliche Beschreibung, wie Du sie ablieferst wirkt da schon deutlich schneller!)!

Wie soll ich denn was von Grund auf selbst schreiben, von dem ich nicht weiß wie es geht? Da muss ich mich ja erst einlesen, und dabei tauchten dann genau die Fragen auf!

Zitat:

---

Ein 24 bit RGB Wert besteht aus Rot, Grün und Blau Werten jeweils zwischen 0-255 (8-Bit). Was wir machen werden ist, einen (Pseudo-)Zufallswert X ermitteln und den dann sichtbar machen, indem wir ihn in einen RGB Wert verwandeln.
Es gibt viele Möglichkeiten das zu tun, die einfachste ist, X sofort zwischen 0..255 zu berechnen und dann R=X, G=X, B=X zu machen. Dadurch bekommen wir Grauwerte. Wenn du einen bestimmten Farbwert vorgeben willst, dann geht das so:

---

Zitat:

---

Sagen wir, wir wollen ein 8x8 Pixel grossen Muster berechnen.
Dann berchnen wir 64 solcher X Werte und plotten sie der Reihe nach in das 8x8 Quadrat.

Das ist bis jetzt noch kein Perlin Noise Muster, sondern nur "triviale" Noise.

---

Zitat:

---

Die Idee die Perlin hatte ist, dass man verschiedene Schichten von Rauschen übereinanderlegt

---

Zitat:

---

Eine Persistenz von 0.5 bedeutet, dass wir von einer Schicht zur nächsten die höhe der Erhebungen/Täler halbieren.
So eine Schicht nennt man auch "Oktave", weil bei Perlin Noise üblicherweise die nächste schicht immer doppelt so fein ist, wie die Frequenzen in der Musik
sich von einer Oktave zur nächsten verdoppeln.

---

Zitat:

---

Also schauen wir uns erstmal mal 4x4 an.
Da gehen wir so vor, dass wir wie die 8x8 Schicht das berechnen, nur eben 4x4 gross, also 16 Zufallswerte.
Wenn wir das jetzt mit 8x8 mischen wollen, müssen wie 4x4 auf 8x8 "zoomen".
Also zwischen den einzelnen Werten brauchen wir noch einen Zwischenwert, den wir durch Interpolation der
beiden drumherum leigenden bekommen, also irgendwie ein mittel finden.
Im einfachsten Fall ist das die lineare Interpolation, also setzen wir immer das mittel dazwischen.

---

Zitat:

---

Bei Verdopplung ist die lineare inerpolation gerade das arithmetische mittel zwischen den benachbarten Punken.

---

Zitat:

---

haben wir eine Persistenz von 0.5, dann
nehmen wir das 2x2 Array, addieren die Zahlen von 4x4 drauf mit 0.5 multipliziert und die von 8x8 mit 0.5*0.5 = 0.25 multipliziert.

Also

X = X_2 + X_4*0.5 + X_8*0.25

Da der Wertebereich von X jetzt von 0..255*(1+0.5+0.25) = 0..446.25 geht, scalieren wir X noch

X = X * 255 / 446.25

---

Zitat:

---

Das dient dann als Ausgangsmaterial für alle möglichen Spielereien.

Bild: http://www.hd-rec.de/pics/perlin1.jpg Bild: http://www.hd-rec.de/pics/perlin2.jpg Bild: http://www.hd-rec.de/pics/perlin3.jpg

Bild: http://www.hd-rec.de/pics/growgrass.png

Bild: http://www.hd-rec.de/pics/mountain_grass4.jpg

---

[ - Antworten - Zitieren - Direktlink - ]

code:

---

source_width  = ... // dimensionen des quell bildes
source_height = ...

For dest_y=0 to dest_width-1 // gehe über alle ziel bild pixel
  For dest_x=0 to dest_height-1
    source_x = dest_x * source_width/dest_width   // wo liegt unser pixel
    source_y = dest_y * source_height/dest_height // auf dem quell bild ?

    source_intx = Floor(source_x)       // ganzzahlige coos ermitteln
    source_inty = Floor(source_y)
    x_frac = source_x - source_intx  // überschüssige bruchteile ermitteln
    y_frac = source_y - source_inty 
 
    weight11 =    (x_frac  *    y_frac)  // gewichte für die umliegenden
    weight21 = ((1-x_frac) *    y_frac)  // pixel bestimmen
    weight12 =    (x_frac  * (1-y_frac))
    weight22 = ((1-x_frac) * (1-y_frac))

    dest_pixel(dest_x,dest_y) =
             source_pixel(source_intx  ,source_inty  ) * weight11 // neuen ziel pixel zusammen setzen
           + source_pixel(source_intx+1,source_inty  ) * weight21 // aus den vier umliegenden
           + source_pixel(source_intx  ,source_inty+1) * weight12 // quell pixeln
           + source_pixel(source_intx+1,source_inty+1) * weight22    

  Next
Next

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Der_Wanderer:
Bei linearer Interpolation betrachtet man immer vier Pixel, um einen zu berechnen, und zwar einen 2x2 block. Man berechnet den Wert dann in Abhängigkeit von der Nähe, linear interpoliert.

---

Zitat:

---

"Löcher" gibt es dadruch, dass man die werte einfach ab einem bestimmen schwellwert abclippt, z.B. unter 50 setzt man gar keinen Pixel.

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Der_Wanderer:
@Reth:
Ich weiss nicht was du hast. Auf der freespace seite wird das alles ausführlich erklärt. Dort wird die lineare und cosinus interpolation mit zwei Punkten und die cubische mit mehr punkten erklärt. (1 Dimensional)

---

Zitat:

---

In dem Sourcecode von meinem letzen Posting siehst du genau wie es geht.

Lineare Interpolation:
Sagen wir du hast an der stelle 5 der Wert 100 und an der stelle 6 den Wert 200.

Dann hast du an der stelle 5.2 den Wert

frac = 5.2 - Floor(5.2) = 5.2 - 5.0 = 0.2
y = (1-frac) * 100 + frac * 200
= 0.8 * 100 + 0.2 * 200 = 80 + 40 = 120

Wenn es zweidimensional ist, dann kommen eben noch unten zwei pixel dazu, und es gibt einen frac_x und frac_y.

---

[ - Antworten - Zitieren - Direktlink - ]

code:

---

dest_x = 5 // coos auf 8x8
dest_y = 0

=>
source_x = 5 * source_width/dest_width // coos auf 2x2
         = 5 * 2 / 8 = 1.25
source_y = 0 * ... = 0

Zur berechnung brauchen wir nun alle umliegenden Pixel von
(1.25,0), was i.A. 4 Stück sind: (1,0); (2,0); (1,1); (2,1)

source_pixel(1,0)
source_pixel(2,0) = source_pixel(0,0)
source_pixel(1,1)
source_pixel(2,1) = source_pixel(0,1)

Da es (2,0) auf der 2x2 nicht gibt, müssen wir wrappen und landen wieder auf 0, ist also ein spezialfall weil es am rand liegt.

Jetzt müssen wir uns berechnen, wie nahe der gewünschte dest_pixel(5,0) = source_pixel(1.25,0) an den jeweiligen Nachbarn liegt.
Der dest_pixel(5,0) entspricht ja dem source_pixel(1.25,0), wie wir jetzt wissen, nur können wir ja keine viertel Pixel auslesen.

Von (1,0) hat (1.25,0) in x richtung den abstand dist_x = 0.25 und in y Richtung dist_y = 0.

Er ist also näher an (1,0) als an (2,0), aber bekommt noch etwas von (2,0) ab.
Er bekommt daher den Wert anteilig von beiden, so dass die anteile zusammen 1 ergeben:

wert_oben = source_pixel(1,0) * (1-dist_x) + source_pixel(2,0) * dist_x
          = source_pixel(1,0) * 0.75 + source_pixel(2,0) * 0.25

Jetzt fehlen aber noch die unteren beiden.
Also kommt noch dazu nach dem gleichen x-Verhältnis.

wert_unten = source_pixel(1,1) * 0.75 + source_pixel(2,1) * 0.25

Die beiden müssen wir jetzt noch im y-verhältnis zusammen addieren:

wert = wert_oben * 1 + wert_unten * 0

Normalerweise ist das untere natürlich nicht 0, das passiert nur weil es genau auf der reihe liegt.

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Der_Wanderer:
Zur berechnung brauchen wir nun alle umliegenden Pixel von
(1.25,0), was i.A. 4 Stück sind: (1,0); (2,0); (1,1); (2,1)

---

Zitat:

---

Da es (2,0) auf der 2x2 nicht gibt, müssen wir wrappen und landen wieder auf 0, ist also ein spezialfall weil es am rand liegt.

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Der_Wanderer:
> Gibt es einen Grund, warum nur die darunter und rechts daneben liegenden Pixel betrachtet werden und nicht alle umliegenden?
Ja. Es gibt nur 4 umgebende Pixel.
Beispiel:
Nimm einen Bleistif und mache zufällig einen Punkt auf karriertes
Papier. Jetzt gibt es genau 4 Ecken (=Pixel), die diesen Punkt einschliessen.

---

[ - Antworten - Zitieren - Direktlink - ]

code:

---

(3  |  5) = (3|5)
(3+1|  5) = (4|5)
(3  |5+1) = (3|6)
(3+1|5+1) = (4|6)

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

code:

---

source_intx = Floor(source_x)       // ganzzahlige coos ermitteln
source_inty = Floor(source_y)
x_frac = source_x - source_intx  // überschüssige bruchteile ermitteln
y_frac = source_y - source_inty

---

code:

---

weight11 =    (x_frac  *    y_frac)  // gewichte für die umliegenden
weight21 = ((1-x_frac) *    y_frac)  // pixel bestimmen
weight12 =    (x_frac  * (1-y_frac))
weight22 = ((1-x_frac) * (1-y_frac))

---

code:

---

dest_pixel(dest_x,dest_y) =
         source_pixel(source_intx  ,source_inty  ) * weight11 // neuen ziel pixel zusammen setzen
       + source_pixel(source_intx+1,source_inty  ) * weight21 // aus den vier umliegenden
       + source_pixel(source_intx  ,source_inty+1) * weight12 // quell pixeln
       + source_pixel(source_intx+1,source_inty+1) * weight22

---

code:

---

obere_reihe  = source_pixel(source_intx   ,source_inty) * (1-x_frac) 
             + source_pixel(source_intx+1 ,source_inty) * (x_frac)
untere_reihe = source_pixel(source_intx   ,source_inty+1) * (1-x_frac) 
             + source_pixel(source_intx+1 ,source_inty+1) * (x_frac)

// ... und jetzt die beiden Reihen y interpolieren:

dest_pixel(dest_x,dest_y) = obere_reihe * (1-y_frac) + unter_reihe * y_frac

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Der_Wanderer:
Also die Formel ist hier, nur in mehreren Schritten:

code:

---

source_intx = Floor(source_x)       // ganzzahlige coos ermitteln
source_inty = Floor(source_y)
x_frac = source_x - source_intx  // überschüssige bruchteile ermitteln
y_frac = source_y - source_inty

---

Hier wird der Bruchteil ermittelt, der zum rechten/oberen Pixel fehlt

---

Hm? Zum linken/oberen Pixel, oder versteh ich das falsch (will nicht pedantisch sein, aber kann ja sein, dass jmd. das Ganze später auch mal zu Rate zieht, wird glaub ich gerade ein tolles Tutorial !)?

Zitat:

---

Man könnte es auch splitten und folgendes machen:

code:

---

obere_reihe  = source_pixel(source_intx   ,source_inty) * (1-x_frac) 
             + source_pixel(source_intx+1 ,source_inty) * (x_frac)
untere_reihe = source_pixel(source_intx   ,source_inty+1) * (1-x_frac) 
             + source_pixel(source_intx+1 ,source_inty+1) * (x_frac)

// ... und jetzt die beiden Reihen y interpolieren:

dest_pixel(dest_x,dest_y) = obere_reihe * (1-y_frac) + unter_reihe * y_frac

---

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Der_Wanderer:
Ich kann dir aber verraten, wie die meisten Tree-Gens funktionieren, und zwar mit einer (i.A. contextfreien) Grammatik.
Das thema hatten wir hier in einem Thread schonmal besprochen.

http://www.amiga-news.de/forum/thread.php?id=27069&BoardID=7

---

Zitat:

---

Ansonsten kannst du dir den "TreeGen" angucken im Amiblitz3 Archive, allerdings ist das sehr (sehr!) Alpha und der Sourcecode nicht sehr aufgeräumt. Aber ich werde das ausbauen und mit einer hübschen GUI versehen.

Allerdings solltest du dich vorher mehr in Mathe und 3D Sachen fitter machen. Das ist schon anspruchsvoller als Perlin Noise.

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]