JAVA Mandelbrot-Menge

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • JAVA Mandelbrot-Menge

    Die Mandelbrot-Menge, im allgemeinen Sprachgebrauch oft auch "Apfelmännchen" genannt, ist ein Fraktal, das in der Chaostheorie eine bedeutende Rolle spielt. Es wurde 1980 von Benoît Mandelbrot erstmals computergrafisch dargestellt und untersucht. Die mathematischen Grundlagen dafür wurden bereits 1905 von dem französischen Mathematiker Pierre Fatou erarbeitet.

    sicherlich nützlich bei der lösung sind folgende dokumente
    - http://www.thegeek.de/src/fraktal.phps
    - http://www.htwm.de/~if99/grundstudium/java_pr/Praktikum14.htm
    - http://www.mathematische-basteleien.de/apfelmaennchen.htm (mit weiterer literaturliste)

    Quellcode

    1. import java.io.*;
    2. import java.io.IOException;
    3. import java.util.Formatter;
    5. /**
    6. *
    7. * @author Torben Brodt
    8. * @version 1.0
    9. *
    10. * <p />Fraktale Geometrie & Komplexe Zahlen: Mandelbrot
    11. */
    12. public class A1_Mandelbrot {
    14. /**
    15. * @param args
    16. * 0 => dateiname
    17. * 1 => xmin
    18. * 2 => xmax
    19. * 3 => length
    20. * 4 => dimension
    21. * 5 => maxIt
    22. */
    23. public static void main(String[] args) {
    24. // TODO Auto-generated method stub
    25. double xmin=0.0, xmax=0.0, length=0.0;
    26. int dimension=0,maxIt=0;
    27. String dateiname="";
    29. try {
    30. // Imaginärteil
    31. xmin = Double.parseDouble(args[1]); //-2
    32. xmax = Double.parseDouble(args[2]); //-2
    33. length = Double.parseDouble(args[3]); //4
    35. // Realteil
    36. dimension = Integer.parseInt(args[4]); //400
    37. maxIt = Integer.parseInt(args[5]); //254
    38. dateiname = args[0]; //mandelbrot.pgm
    40. } catch(Exception e) {
    41. error_msg("Fehler bei der Eingabe");
    42. }
    44. //Andere Fehler abfangen
    45. if(dimension <= 0) error_msg("Fehler: Dimension <= 0");
    46. if(length <= 0) error_msg("Fehler: Laenge <= 0");
    47. if(maxIt <= 0) error_msg("Fehler: Grauwert <= 0");
    50. int draw[][] = new int[dimension][dimension];
    51. //double d_dimension = (double)dimension; //perfomanter als in der schleife zu casten?
    53. // x & y => Imaginärteil in Mandelfeldern (z.B. -2 bis 2)
    54. // i & j => Realteil in Pixeln (z.B. 0 bis 400)
    55. double x=xmin;
    56. for (int i=0 ; i<dimension ; i++) {
    57. double y=xmax;
    58. for (int j=0 ; j<dimension ; j++) {
    59. draw[j][i] = greytone(x, y, maxIt);
    60. y += length / dimension;
    61. }
    62. x += length / dimension; //Schrittweite = Quotient von Länge(Imaginär) und Bildgröße(Real)
    63. }
    65. try {
    66. pgm(draw, dateiname, dimension, maxIt);
    67. } catch(Exception e) {
    68. System.out.println("Fehler");
    69. }
    71. System.out.print("Das Mandelbrot wurde erstellt");
    72. }
    74. /**
    75. * Draws a PGM Picture
    76. * @param draw -> Array
    77. * @param filename -> Dateiname
    78. * @param maxIt -> Maximaler Grauwert (für den Header)
    79. * @throws IOException
    80. */
    81. static void pgm(int[][] draw, String filename, int dimension, int maxIt) throws IOException
    82. {
    83. Formatter output = new Formatter(new File(filename));
    85. // Header schreiben
    86. output.format("P2\n#"+filename+"\n"+draw[0].length+" "+draw.length+"\n"+maxIt+"\n");
    88. // Array schreiben
    89. for(int i=dimension-1; i>=0; i--) { //umgekehrt steht "es" auf den Fuessen
    90. for(int point : draw[i])
    91. output.format(point+" ");
    92. output.format("\n");
    93. }
    94. output.close();
    95. }
    97. /**
    98. * Returns the Greytone
    99. * @param xmin = imaginärteil - x-Koordinate
    100. * @param xmax = imaginärteil - y-Koordinate
    101. * @param maxIt
    102. * @return
    103. */
    104. static int greytone(double xmin, double xmax, int maxIt) {
    105. double old_x, old_y, new_x=0, new_y=0;
    107. int greytone = maxIt; //von 0 oder von 1?
    109. do {
    110. old_x = new_x;
    111. old_y = new_y;
    113. // x_1 = x_0^2 - y_0^2 + x_1 ~> (1)
    114. new_x = (old_x * old_x) - (old_y * old_y) + xmin;
    115. // y_1 = 2 * x_0 * y_0 + y_1 ~> (1)
    116. new_y = 2 * (old_x * old_y) + xmax;
    118. greytone--;
    120. // Betrag = sqrt(a_1^2 + b_1^2)
    121. // Bedingung = Betrag^2 < 4
    122. if ((new_x*new_x) + (new_y*new_y) >= 4)
    123. return greytone;
    125. } while (greytone > 0);
    127. return greytone;
    128. }
    129. //Quellen: (1) http://www.mathematische-basteleien.de/apfelmaennchen.htm
    131. static void error_msg(String text)
    132. {
    133. System.out.println(text);
    134. System.exit(-1);
    135. }
    136. }
    Alles anzeigen
    Bilder

    • mandelbrot.gif

      33,6 kB, 615×432, 3.177 mal angesehen

  • Meine Lösung:

    Hallo miteinander,
    hier meine Lösung des Problems, die Grauwerte werden rekursiv errechnet, Imaginär- und Realteil in einem 3-Dimensionalen Array gespeichert. Ab einer Pixelzahl von 1000 kann es daher zu einem "java.lang.OutOfMemoryError: Java heap space" Error kommen.


    Quellcode

    1. import java.util.*;
    2. import java.io.*;
    4. /**
    5. * Medieninformatik, I.Semester / FH-Wiesbaden<br>
    6. * Ubungsblatt 10<br>
    7. * <br>
    8. * Das Programm erzeugt eine Datei, welche einen beliebigen Ausschitt der Mandelbrot-Menge zeigt<br>
    9. * <br>
    10. * getestet mit WinXP, Servicepack2 / Java 5.0<br>
    11. * @author Sebastian Schmitt
    12. * @version 1.0
    13. */
    17. public class mandelbrot {
    19. /**
    20. * @param args Komadozeilenparameter
    21. */
    22. public static void main(String[] args)
    23. throws FileNotFoundException{
    25. if (args.length!=6 || !(isStringDouble(args[0])) || !(isStringDouble(args[1])) ||//pruefe Abbruchbedingungen
    26. !(isStringDouble(args[2])) || !(isStringInt(args[3])) || !(isStringInt(args[4])))
    27. error();
    28. else{
    29. double leftx = Double.parseDouble(args[0]); //linker rand
    30. double lefty = Double.parseDouble(args[1]); //unterer rand
    31. double size = Double.parseDouble(args[2]); //groesse
    32. int pixel = Integer.parseInt(args[3]); //Anzahl pixel pro Achse
    33. int grey = Integer.parseInt(args[4]); //AnzahlGraustufen
    36. double field[][][] = new double [pixel][pixel][2]; //Erzeuge Array
    38. double delta = size/pixel;
    40. for (int i=0;i<pixel;i++) //Weise den Arrayfeldern die Werte der komplexen Zahlen zu
    41. for (int j=0; j<pixel;j++){
    42. field [i][j][0]= leftx + (i*delta);
    43. field [i][j][1]= lefty + size - (j*delta);
    44. }
    46. int grauwerte[][]= new int [pixel][pixel];//Erzeuge neues Array für ergebnisse
    48. for (int i=0;i<pixel;i++) //schreibt in das neue Array ueber die rekursive
    49. for (int j=0;j<pixel;j++){ //Funktion konvergenz() die Ergebnisse/Grauwerte
    50. grauwerte[i][j]=grey - konvergenz(field[i][j][0],field[i][j][1],0,0,0,grey);
    51. }
    53. Formatter ausgabe = new Formatter (new File(args[5])+".pgm");
    55. ausgabe.format("%s\n %s %s\n %s %s\n %s\n","P2","#",args[5]+".pgm",pixel,pixel,grey);
    56. //Formatiert den Kopf der pgm-Datei
    57. for (int i=0;i<pixel;i++) //Schreibt die Grauwerte in die pgm-Datei
    58. for (int j=0;j<pixel;j++){
    59. if (j==pixel-1)
    60. ausgabe.format("%2d\n ",grauwerte[j][i]);
    61. else
    62. ausgabe.format("%2d ",grauwerte[j][i]);
    63. }
    64. ausgabe.close();
    65. }
    66. }
    68. /**
    69. * Die Funktion errechnet rekursiv die Werte der Mandelbrot-Folge
    70. *
    71. * @param a Realteil d. Kompl. Zahl
    72. * @param b Imaginaerteil d. Kompl. Zahl
    73. * @param c Re(n-1)
    74. * @param d Im(n-1)
    75. * @param z Zaehler
    76. * @param max maximale Graustufen
    77. * @return Anzahl maximaler Iterationen
    78. */
    79. static int konvergenz(double a,double b,double c,double d, int z, int max){
    80. if (((c*c)+(d*d))>4)
    81. return z;
    82. else if (z==0)
    83. return konvergenz(a,b,a,b,z+1,max);
    84. else if (z==max)
    85. return z;
    86. else
    87. return konvergenz(a,b,(c*c)-(d*d)+a,(2*c*d)+b,z+1,max);
    88. }
    89. /**
    90. * Die Funktion prueft, ob ein String ein Double ist
    91. * @param str Komandozeilenparameter-String
    92. * @return true/false
    93. */
    94. static boolean isStringDouble(String str){
    96. char zahl[]=new char [str.length()];
    97. int zaehler=0,punkt=0;
    99. for (int i=0;i<str.length();i++){
    100. zahl[i]=str.charAt(i);
    101. if ( !((Character.isDigit(zahl[i])) || (zahl[i]=='.') || (zahl[i]=='-')))
    102. zaehler+=1;
    103. if (zahl[i]=='.')
    104. punkt+=1;
    105. }
    106. if (zaehler!=0 || punkt>1) return false;
    107. else return true;
    109. }
    110. /**
    111. * Die Funktion prueft, ob ein String ein Integer ist
    112. * @param str Komandozeilenparameter-String
    113. * @return true/false
    114. */
    115. static boolean isStringInt(String str){
    117. char zahl[]=new char [str.length()];
    118. int zaehler=0;
    120. for (int i=0;i<str.length();i++){
    121. zahl[i]=str.charAt(i);
    122. if ( !((Character.isDigit(zahl[i])) || (zahl[i]=='-')))
    123. zaehler+=1;
    124. }
    125. if (zaehler==0) return true;
    126. else return false;
    128. }
    129. /**
    130. * Die Funktion informiert bei falscher Benutzung
    131. * ueber die Handhabung des Programmes
    132. */
    133. static void error(){
    134. System.out.println("Falsche Eingaben, bitte beim naechsten Mal folgendermassen vorgehen:");
    135. System.out.println("- param1 u. param2: geben die untere, linke Ecke des Bildausschnittes an ");
    136. System.out.println("- param3: gibt die groesse des Bildausschnittes an ");
    137. System.out.println("- param4: gibt die Anzahl der Pixel horizontal und vertikal an");
    138. System.out.println("- param5: gibt die Anzahl der Graustufen an ");
    139. System.out.println("- param6: gibt den Namen der Zieldatei an (Bitte ohne Endung!)");
    140. }
    142. }
    Alles anzeigen