import java.awt.Color;
public class DLA {
public static void main(String[] args) {
// Feld fuer Kollisionsueberpruefung erstellen
int[][] field = new int[400][400];
// Grenzen fuer Koordinaten der Partikel aus field berechnen (.length
// verwenden)
int maxX = field.length;
int maxY = field[0].length;
// Fenster fuer Grafikausgabe vorbereiten und anzeigen
Pad drawPad = new Pad();
drawPad.setBackground(Pad.black);
drawPad.setPadSize(maxX, maxY);
drawPad.setVisible(true);
drawPad.setColor(Pad.white);
// "Samen" erzeugen, also den ersten Pixel aufs Feld setzen (Color: Pad.white)
// Hier: Pixel wird genau in die Mitte des Feldes gesetzt - andere Startpixel waeren moeglich
setPixel(drawPad, field, maxX / 2, maxY / 2, Pad.white);
// Berechne fuer alle bereits vorhandenen Partikel den Abstand zum Zentrum des Feldes
// speichere das Maximum dieser Abstaende in maxR
int maxR = 0;
for (int x = 0; x < maxX; x++) {
for (int y = 0; y < maxY; y++) {
if (testPixel(field, x, y)) {
maxR = (int) Math.max(maxR, Math.sqrt(Math.pow(
(x - maxX / 2), 2)
+ Math.pow((y - maxY / 2), 2)));
}
}
}
// Abbruchbedingung: Hat aeusserster Pixel den Rand des Feldes erreicht?
boolean isAtBorder = false;
// Schleife: Solange maxR nicht den Rand des Feldes
// beruehrt, sollen neue Punkte gezeichnet werden
while (!isAtBorder) {
// auf einem gedachten Kreis um den Mittelpunkt mit Radius maxR + 20 einen Partikel "erzeugen"
// d.h. die Koordinaten eines zufaelligen Punktes auf dem Kreisrand berechnen
// neuer Partikel ist somit an Position movingPixelX ; movingPixelY
double x = Math.random() * 360;
int movingPixelX = limit((int) (Math.cos(x) * (maxR + 20)) + maxX
/ 2, 0, maxX);
int movingPixelY = limit((int) (Math.sin(x) * (maxR + 20)) + maxY
/ 2, 0, maxY);
// Nun Start der brownschen Bewegung
// Partikel bewegt sich, bis er einen bereits vorhandenen Partikel beruehrt oder bis er das Feld verlaesst
while (!isTouching(field, movingPixelX, movingPixelY)
&& inRange(movingPixelX, movingPixelY, maxR + 30, maxX,
maxY)) {
//zufaelliges Verschieben des Partikels um +/- 1 Pixel mit moveRandom
movingPixelX = moveRandom(movingPixelX);
movingPixelY = moveRandom(movingPixelY);
}
// Brownsche Bewegung zu Ende - Ist Partikel auf einen bereits vorhandenen Partikel gestossen?
if (isTouching(field, movingPixelX, movingPixelY)) {
// Wenn ja: Partikel ist jetzt "fest" an dieser Stelle, zeichne einen Punkt dort
// Farbwertberechnung fuer 1337 blau-Effekt
int k = limit(
255 - (int) (255 * ((double) maxR * 2) / (double) maxX),
0, 255);
Color c = new Color(255, k, k);
// den Partikel setzen und zeichnen
setPixel(drawPad, field, movingPixelX, movingPixelY, c);
// Abstand des neu gesetzten Partikels zum Mittelpunkt des Feldes berechnen
// wenn groesser als alter maximaler Abstand maxR, dann Maximum mit neuem Abstandswert ueberschreiben
maxR = (int) Math.max(maxR, Math.sqrt(Math.pow(
((double) movingPixelX - (double) maxX / 2), 2)
+ Math.pow(((double) movingPixelY - (double) maxY / 2),
2)));
// Falls der Partikel das Feld verlassen hat: Zeichnung ist fertig, setze Abbruchkriterium der aeusseren Schleife auf true
if (movingPixelX - 1 <= 0 || movingPixelX + 1 >= maxX
|| movingPixelY - 1 <= 0 || movingPixelY + 1 >= maxY) {
isAtBorder = true;
}
}
// System.out.println(maxX + "\t" + maxY + "\t " + maxR + "\t"
// + movingPixelX + "\t" + movingPixelY + "\t"+isAtBorder);
}
}
// ...Math.toRadians(
public static void setPixel(Pad drawPad, int[][] field, int x, int y,
Color c) {
/**
* Pruefe, ob sich der Partikel an Koordinaten (x,y) innerhalb des Feldes befindet
* Wenn ja, speichere ihn fest im Feld an dieser Stelle zeichne dort einen Punkt
*/
if (x > 0 && y > 0 && x < field.length - 1 && y < field[0].length - 1) {
field[x][y] = 1;
drawPad.setColor(c);
drawPad.drawDot(x, y);
}
}
/**
* Prüft ob sich ein Punkt innerhalb eines Radius vom Mittelpunkt eines
* Rechtecks befindet
*
* @param x
* die x Koordinate des fields
* @param y
* die y Koordinate des fields
* @param maxR
* der Radius
* @param maxX
* die x Koordinate des Rechtecks
* @param maxY
* die y Koordinate des Rechtecks+30
*/
public static boolean inRange(int x, int y, int maxR, int maxX, int maxY) {
// Mittelpunkt des Rechtecks ausrechen
int middleX = maxX / 2;
int middleY = maxY / 2;
// Der Abstand vom Mittelpunkt sqrt(a² + b²) mit Hilfe der in Java
// intigrierten Klasse "Math"
int distance = (int) Math.sqrt(Math.pow((x - middleX), 2)
+ Math.pow((y - middleY), 2));
if (distance < maxR) {
return true;
}
return false;
}
/**
* Testet ob das gegebene Pixel an ein anderes grenzt
*
* @param field
* das Array von Pixeln
* @param x
* die x Koordinate des fields
* @param y
* die y Koordinate des fields
* @return grenzt an ein anders Pixel (true) oder nicht (false)
*/
public static boolean isTouching(int[][] field, int x, int y) {
// ist eigentlich unschön, in diesem Fall aber wesentlich einfacher zu
// lesen und zu verstehen
if (testPixel(field, x - 1, y - 1) || testPixel(field, x - 1, y)
|| testPixel(field, x - 1, y + 1) || testPixel(field, x, y - 1)
|| testPixel(field, x, y + 1) || testPixel(field, x + 1, y - 1)
|| testPixel(field, x + 1, y) || testPixel(field, x + 1, y + 1)) {
return true;
}
return false;
// #TODO ergänzen
}
/**
* Testet ob der Wert des Pixels größer 0 ist. (Falls der Wert außerhalb der
* Grenzen ist wird er mit der limit() Methode gelimited)
*
* @param field
* das Array von Pixeln
* @param x
* die x Koordinate des fields
* @param y
* die y Koordinate des fields
* @return ob der Wert größer 0 ist (true) oder nicht (false)
*/
public static boolean testPixel(int[][] field, int x, int y) {
// länge des ersten arrays
x = limit(x, 0, field.length - 1);
y = limit(y, 0, field[0].length - 1);
// länge des zweiten arrays
if (field[x][y] > 0) {
return true;
}
return false;
}
/**
* Limitiert einen Wert auf einen Bereich
*
* @param value
* der zu limitierende Wert
* @param lower
* die untere Grenze
* @param upper
* die obere Grenze
* @return den limitierten Wert
*/
public static int limit(int value, int lower, int upper) {
if (value < lower) {
return lower;
}
if (value > upper) {
return upper;
}
return value;
}
/**
* Bewegt eine Pixelkoordinate randommäßig -1, +1 oder gar nicht
*
* @param movePixel
* die zu bewegende Pixel-Koordinate
* @return die Bewegte Pixel-Koordinate
*/
public static int moveRandom(int movePixel) {
// erstelle eine random-Zahl zwischen 1 und
int random = 1 + (int) (Math.random() * 3);
// Math.random() gibt eine double-Zahl >= 0.0 und < 1.0 zurück
switch (random) {
case 1:
return movePixel - 1;
case 2:
return movePixel;
default:
return movePixel + 1;
}
}
}
