Javakurs/Übungsaufgaben/DiffusionLimitedAggregation/Musterlösung

import java.awt.Color;

public class DLA {
	public static void main(String[] args) {
		// Feld erstellen, in dem gespeichert wird, ob an gegebenen Koordinaten
		// ein Partikel ist
		int[][] field = new int[400][400];

		// Maximalwerte fuer Koordinaten der Partikel, lassen sich aus den
		// Dimensionen von 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);

		// Abstand des Partikels, der am weitesten vom Zentrum des Feldes
		// entfernt ist
		int maxR = 0;

		// Falls der Startpunkt auch ein anderer sein kann als das Zentrum des
		// Feldes:
		// Berechne fuer alle bereits vorhandenen Partikel den Abstand zum
		// Zentrum des Feldes
		// speichere das Maximum dieser Abstaende in maxR
		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 einer der Partikel sich aus dem Feld heraus
		// bewegt?
		boolean isAtBorder = false;

		// Schleife: Erstelle solange neue Partikel, wie die Abbruchbedingung
		// false ist
		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);
		}
	}

	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;
	}

	/**
	 * 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;
		}
	}
}