Javakurs/Übungsaufgaben/DiffusionLimitedAggregation/Musterlösung - Versionsgeschichte

MarkusH: fix alignment

2013-03-04T19:29:49Z

fix alignment

Änderungen zeigen

Theresa: ein paar Kommentare geändert

2012-03-07T15:59:50Z

ein paar Kommentare geändert

Theresa: Kommentare ergänzt

2012-03-07T14:57:16Z

Kommentare ergänzt

Jörg F: hat „Javakurs2007/DiffusionLimitedAggregation/Musterlösung“ nach „Javakurs/Übungsaufgaben/DiffusionLimitedAggregation/Musterlösung“ verschoben: wikistruktur

2010-08-01T11:56:25Z

hat „Javakurs2007/DiffusionLimitedAggregation/Musterlösung“ nach „Javakurs/Übungsaufgaben/DiffusionLimitedAggregation/Musterlösung“ verschoben: wikistruktur

Jörg F: erste Version einer Musterlösung

2010-03-28T14:33:37Z

erste Version einer Musterlösung

Neue Seite

<pre>
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 Partikel in der Mitte des Feldes
// setzen (Color: Pad.white)
setPixel(drawPad, field, maxX / 2, maxY / 2, Pad.white);

// Radius des Partikels der am weitesten vom Zentrum entfernt ist
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
boolean isAtBorder = false;

// Schleifenkopf, solange maxR nicht den Rand des Fensters
// beruehrt, sollen neue Punkte gezeichnet werden
while (!isAtBorder) {
// einen Punkt auf einem Kreis um den Mittelpunkt mit dem Radius
// maxR+20 erzeugen
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);

// Schleife zum bewegen des Partikels
while (!isTouching(field, movingPixelX, movingPixelY)
&& inRange(movingPixelX, movingPixelY, maxR + 30, maxX,
maxY)) {
// Partikelkoordinaten zufaellig bewegen (moveRandom)
movingPixelX = moveRandom(movingPixelX);
movingPixelY = moveRandom(movingPixelY);
}

// Schleife zuende, ueberpruefe ob eine Beruehrung vorliegt:
if (isTouching(field, movingPixelX, movingPixelY)) {
// 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);

// Radius zum Mittelpunkt berechnen,
// wenn groesser als altes Maximum, ueberschreiben
maxR = (int) Math.max(maxR, Math.sqrt(Math.pow(
((double) movingPixelX - (double) maxX / 2), 2)
+ Math.pow(((double) movingPixelY - (double) maxY / 2),
2)));
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) {

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

}

}

</pre>

@@ Zeile 5: / Zeile 5: @@
 	public static void main(String[] args) {
-		// Feld fuer Kollisionsueberpruefung erstellen
+		//Feld erstellen, in dem gespeichert wird, ob an gegebenen Koordinaten ein Partikel ist
 		int[][] field = new int[400][400];
-		// Grenzen fuer Koordinaten der Partikel aus field berechnen (.length
+		//Maximalwerte fuer Koordinaten der Partikel, lassen sich aus den Dimensionen von field berechnen (.length verwenden)
 		int maxX = field.length;
 		int maxY = field[0].length;
@@ Zeile 23: / Zeile 22: @@
                  // 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
+                //Abstand des Partikels, der am weitesten vom Zentrum des Feldes entfernt ist
                  // speichere das Maximum dieser Abstaende in maxR
 		for (int x = 0; x < maxX; x++) {
 			for (int y = 0; y < maxY; y++) {
@@ Zeile 38: / Zeile 40: @@
+		}
-		// Abbruchbedingung: Hat aeusserster Pixel den Rand des Feldes erreicht?
+		//Abbruchbedingung: Hat einer der Partikel sich aus dem Feld heraus bewegt?
 		boolean isAtBorder = false;
-		// Schleife: Solange maxR nicht den Rand des Feldes
+		//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"

@@ Zeile 20: / Zeile 20: @@
 		drawPad.setColor(Pad.white);
-		// "Samen" erzeugen. Also den ersten Partikel in der Mitte des Feldes
+		// "Samen" erzeugen, also den ersten Pixel aufs Feld setzen (Color: Pad.white)
-		// 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);
-		// Radius des Partikels der am weitesten vom Zentrum entfernt ist
+		// Berechne fuer alle bereits vorhandenen Partikel den Abstand zum Zentrum des Feldes
 		int maxR = 0;
 		for (int x = 0; x < maxX; x++) {
@@ Zeile 37: / Zeile 38: @@
+		}
-		// Abbruchbedingung
+		// Abbruchbedingung: Hat aeusserster Pixel den Rand des Feldes erreicht?
 		boolean isAtBorder = false;
-		// Schleifenkopf, solange maxR nicht den Rand des Fensters
+		// Schleife: Solange maxR nicht den Rand des Feldes
 		// beruehrt, sollen neue Punkte gezeichnet werden
 		while (!isAtBorder) {
-			// einen Punkt auf einem Kreis um den Mittelpunkt mit dem Radius
+			// auf einem gedachten Kreis um den Mittelpunkt mit Radius maxR + 20 einen Partikel "erzeugen"
-			// maxR+20 erzeugen
+                        // d.h. die Koordinaten eines zufaelligen Punktes auf dem Kreisrand berechnen
 			double x = Math.random() * 360;
 			int movingPixelX = limit((int) (Math.cos(x) * (maxR + 20)) + maxX
@@ Zeile 50: / Zeile 53: @@
 			int movingPixelY = limit((int) (Math.sin(x) * (maxR + 20)) + maxY
 					/ 2, 0, maxY);
-−
-			// Schleife zum bewegen des Partikels
+                        // Nun Start der brownschen Bewegung
 			while (!isTouching(field, movingPixelX, movingPixelY)
 					&& inRange(movingPixelX, movingPixelY, maxR + 30, maxX,
 							maxY)) {
-				// Partikelkoordinaten zufaellig bewegen (moveRandom)
 				movingPixelX = moveRandom(movingPixelX);
 				movingPixelY = moveRandom(movingPixelY);
+			}
-			// Schleife zuende, ueberpruefe ob eine Beruehrung vorliegt:
+			// Brownsche Bewegung zu Ende - Ist Partikel auf einen bereits vorhandenen Partikel gestossen?
 			if (isTouching(field, movingPixelX, movingPixelY)) {
 				// Farbwertberechnung fuer 1337 blau-Effekt
 				int k = limit(
@@ Zeile 71: / Zeile 78: @@
 				setPixel(drawPad, field, movingPixelX, movingPixelY, c);
-				// Radius zum Mittelpunkt berechnen,
+				// Abstand des neu gesetzten Partikels zum Mittelpunkt des Feldes berechnen
-				// wenn groesser als altes Maximum, ueberschreiben
+				// 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),
 )));
 				if (movingPixelX - 1 <= 0 || movingPixelX + 1 >= maxX
 						|| movingPixelY - 1 <= 0 || movingPixelY + 1 >= maxY) {
@@ Zeile 92: / Zeile 101: @@
 	public static void setPixel(Pad drawPad, int[][] field, int x, int y,
 			Color c) {
 		if (x > 0 && y > 0 && x < field.length - 1 && y < field[0].length - 1) {

← Nächstältere Version	Version vom 1. August 2010, 11:56 Uhr
(kein Unterschied)