Fraktales Wachstum

Leonard M. Sander u.a. haben Mitte der Achzigerjahre beschrieben, wie sich Teilchen an Flächen oder bereits festsitzenden Teilchen anlagern. Bereits mit einfachen Hilfsmitteln der Java-Programmierung lässt sich dieser Vorgang simulieren: In der Mitte der Querschnittsfläche eines quadratischen Rauchfanges werden Russteilchen freigesetzt, die sich in Zufallsbewegung nach allen 8 Richtungen über die Fläche bewegen. Trifft ein Teilchen die Wand oder ein festsitzendes Teilchen haftet es sogleich fest und das nächste Teilchen wird freigesetzt...

Beispiel: Fraktales Wachstum von Russteilchen

Code:

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.util.Random;

public class Russ extends Applet implements ActionListener {

    Random zufallszahl;
    int teilchenzahl;
    Button ok;
    TextField eingabe;

    public void init () {
	setBackground(Color.white);
	setLayout(new FlowLayout());
	add(new Label("Anzahl der Teilchen: "));
	eingabe = new TextField("1000", 5);
	add(eingabe);
	ok = new Button("ok");
	add(ok);
	ok.addActionListener(this);
	teilchenzahl = Integer.parseInt(eingabe.getText());
    }

    public void actionPerformed (ActionEvent ae) {
	if (ae.getSource() == ok) neuausgeben();
    }

    void neuausgeben() {
	teilchenzahl = Integer.parseInt(eingabe.getText());
	repaint();
    }

    public void paint(Graphics bs) {
	int x;
	int y;

	int zelle[][] = new int[250][250];
	for (int i=0; i<250; i++) 
	    for (int j=0; j<250; j++)
		zelle[i][j]=0;
	
	bs.setColor(Color.white);
	bs.fillRect(0,50,250,230);

	// Quadrat (= Begrenzung) festlegen und ausgeben
	bs.setColor(Color.red);
	x = 20;
	for (int i=0; i<210; i++) {
	    y = i + 20;
	    zelle[x][y] = 1;
	    bs.fillRect(2*x,2*y,2,2);
	}
	y = 20;
	for (int i=0; i<210; i++) {
	    x = i + 20;
	    zelle[x][y] = 1;
	    bs.fillRect(2*x,2*y,2,2);
	}
	x = 230;
	for (int i=0; i<210; i++) {
	    y = i + 20;
	    zelle[x][y] = 1;
	    bs.fillRect(2*x,2*y,2,2);
	}
	y = 230;
	for (int i=0; i<210; i++) {
	    x = i + 20;
	    zelle[x][y] = 1;
	    bs.fillRect(2*x,2*y,2,2);
	}

	// Teilchen erzeugen, torkeln lassen, das angelagerte Teilchen speichern und ausgeben ...
	bs.setColor(Color.black);
	zufallszahl = new Random();

	// Schleife über die festgelegte Teilchenzahl
	for (int i=1; i<teilchenzahl; i++) {
	    boolean erledigt = false;
	    
	    x=125;                 // Startposition in der Mitte des Quadrates
	    y=125;

	    // Schleife für's Torkeln
	    while (!erledigt) {
		
		int torkel = (int) (zufallszahl.nextDouble()*8);     // zufällige Ganzzahl zwischen 0 und 7 
		if (torkel == 0) x+=1;                   // Schritt nach rechts
		if (torkel == 1) y+=1;                   // Schritt nach unten
		if (torkel == 2) x-=1;                   // Schritt nach links
		if (torkel == 3) y-=1;                   // Schritt nach oben
		if (torkel == 4) { x+=1; y+=1; }         // diagonal nach rechts unten
		if (torkel == 5) { x+=1; y-=1; }         // diagonal nach rechts oben
		if (torkel == 6) { x-=1; y-=1; }         // diagonal nach links oben
		if (torkel == 7) { x-=1; y+=1; }         // diagonal nach links unten
    
		// Testen, ob das Nachbarfeld ein Wandelement oder ein angelagertes Teilchen enthält
		if ((zelle[x-1][y+1]==1) || (zelle[x-1][y]==1) || 
		    (zelle[x-1][y-1]==1) || (zelle[x][y+1]==1) || 
		    (zelle[x][y-1]==1) || (zelle[x+1][y+1]==1) || 
		    (zelle[x+1][y]==1) || zelle[x+1][y-1]==1) {

		    zelle[x][y]=1;
		    bs.fillRect(2*x,2*y,3,3);
		    erledigt = true;                     // "Torkel"-Schleife verlassen
		} 
	    } // Ende der "Torkel"-Schleife
	} // Ende der Schleife über die Teilchenzahl
    } // Ende paint()
}

Weitere Beispiele:

Im obigen Beispiel wurde etwa die Anlagerung von Russteilchen an Gefäßwänden (im schwerelosen Raum) simuliert. Ähnlich lässt sich die Anlagerung von Teilchen auf eine horizontale Fläche darstellen: Dazu starten die "taumelnden" Teilchen an einer festen Position oberhalb der Gerade.

Damit die Teilchen nicht außer die Bildfläche gelangen können, wird die Zeichenfläche nach oben und nach unten "begrenzt": Falls die y-Koordinate kleiner 20 wird, erhält das Teilchen genau die y-Koordinate 20; wird die y-Koordinate größer als 250, wird sie auf 250 gesetzt. Für die horizontale Taumelbewegung "kleben" wir die Ausgabefläche zu einem Ring zusammen: Wird die x-Koordinate kleiner als 20 so erhält das Teilchen die x-Koordinate 230 und umgekehrt...

 ...
		if (x<20) x=230;
		if (x>230) x=20;
		if (y<20) y=20;
		if (y>250) y=250;
 ...

Um das zeitliche Geschehen der Anlagerung besser beurteilen zu können, wechseln wir nach verschiedenen Stadien die Farbe der Teilchen:

	...
  	  for (int i=1; i<teilchenzahl; i++) {
	    boolean erledigt = false;

	    x = 125;
	    y = 25;

	    if (i>teilchenzahl*0.05) bs.setColor(dblue);
	    if (i>teilchenzahl*0.1) bs.setColor(dgreen);
	    if (i>teilchenzahl*0.15) bs.setColor(dred);
	    if (i>teilchenzahl*0.2) bs.setColor(Color.blue);
	    if (i>teilchenzahl*0.25) bs.setColor(Color.red);
	    if (i>teilchenzahl*0.35) bs.setColor(dyellow);
	    if (i>teilchenzahl*0.5) bs.setColor(Color.green);
	    if (i>teilchenzahl*0.6) bs.setColor(Color.yellow);
	    if (i>teilchenzahl*0.8) bs.setColor(Color.cyan);
	    if (i>teilchenzahl*0.9) bs.setColor(Color.magenta);
        ...

Im letzten Beispiel kleben wir die quadratische Fläche zu einem Torus zusammen: Dazu legen wir auch für die y-Koordinate fest, dass wie den Wert 230 erhält, wenn sie kleiner als 20 wird und umgekehrt.

 ...
		if (x<20) x=230;
		if (x>230) x=20;
		if (y<20) y=230;
		if (y>230) y=20;
 ...

Zusätzlich lassen wir die Teilchen auf einer Kreislinie um den Mittelpunkt herum starten: Wir halten dabei den Radius fest und wählen eine zufällige Startposition auf dieser Kreislinie, indem wir einen zufälligen Winkel zwischen 0 und 360 Grad ermitteln.

...
 	  for (int i=1; i<teilchenzahl; i++) {
	    boolean erledigt = false;

	    int winkel = (int) (zufallszahl.nextDouble()*360);
	    x = (int) (100 * Math.cos(winkel)+125);
	    y = (int) (100 * Math.sin(winkel)+125);
...

Interessanterweise erhalten wir jedoch ähnliche Korallengebilde, wenn die Startposition des Teilchens fest (etwa an der Position (20/20) gewählt wird. Dies liegt offenbar daran, dass das Teilchen auf einem Torus taumelt...