Ask Question

Name:
Title:
Your Question:

Answer Question

Name:
Your Answer:
User Submitted Source Code!


Description:
  Mandelbrot
Language: JAVA
Code:
import java.awt.*;
import javax.imageio.ImageIO;
import java.io.*;
import java.awt.image.BufferedImage;
import javax.swing.*;

public class Mandelbrot extends JFrame {
     public static void Mandelbrot (int bildbreite, int bildhoehe, double dim, double zoom, double anglex, double angley, double anglez, boolean bulb, double Xoff, double Yoff, double Zoff, int startbild, int endbild, int modus) {
          int i, j, j_neu, k, k_map, n, m, value_change, direktion;
          double farb;

          double koor[] = {0,0,0};
          String dateiname, dateiname_map, dateiname_alpha;

          double verhaeltnis = bildhoehe / bildbreite;
          int bildtiefe = 1024;
          int bildtiefe2 = bildtiefe/2;
          int min = bildtiefe, max = 0;
          double bereich, bereich2;

          if(bulb==false) bildtiefe = 1;
          int pic[][] = new int[bildbreite][bildhoehe];
          int pic_map[][] = new int[bildbreite][bildhoehe];

          double zoom_fest = 33554432;
          zoom_fest = 1;
          double abstandxy, abstandyz, angle_alt, angle_alt_sin, angle_alt_cos, angle_neu, phase_step;
    
          double Xs,Xa;//,Xoff = (double) -0.24947492202520371;
          double Ys,Ya;//,Yoff = (double) 0.7592215285698572;
          double Zs,Za;//,Zoff = (double) 0.0;
//          Xoff = 0;
//          Yoff = 0;

          double dimy = (double) dim;
          double dimx = dimy / verhaeltnis;
          double dimz = (double) dim;
          double verkuerzung = 1;

          // Erstelle neues Bild mit entsprechender Groesse
          int red,green,blue;
          BufferedImage image = new BufferedImage (bildbreite,bildhoehe,BufferedImage.TYPE_INT_RGB);
          Graphics2D graphics = image.createGraphics();

          BufferedImage image_map = new BufferedImage (bildbreite,bildhoehe,BufferedImage.TYPE_INT_RGB);
          Graphics2D graphics_map = image_map.createGraphics();

          BufferedImage image_alpha = new BufferedImage (bildbreite,bildhoehe,BufferedImage.TYPE_INT_RGB);
          Graphics2D graphics_alpha = image_alpha.createGraphics();

          for( m = startbild; m < endbild; m++ ) {      

               switch( modus ) {
                    case 1:
                         anglex = m;
                         phase_step = 0;
                         break;
                    case 2:
                         angley = m;
                         phase_step = 0;
                         break;
                    case 3:
                         anglez = m;
                         phase_step = 0;
                         break;
                    case 4:
                         phase_step = m * 4;
                         break;

                    case 5:
                         anglex = m - 4.5;
                         phase_step = 0;
                         break;

                    default:
                         phase_step = 0;
                         break;
               }
                    
          //               Zoff = dimz;
//               bildtiefe = 1;
//               angley = m;
//               anglez = m;
//               phase_step = m * 4;
      // Berechne den Startpunkt abhaengig von der Dimension, dem Offset und dem Zoomfaktor
      

               // Berechne die Schrittweite von einem zum naechsten Punkt
               double Stepx = 2 / ( ( zoom / dimx ) * bildbreite );
               double Stepy = 2 / ( ( zoom / dimy ) * bildhoehe );
               double Stepz = 1 / ( ( 1 / dimz ) * bildtiefe2 );

               // Zeichne ein schwarzes Rechteck als Hintergrund
               graphics.setColor( new Color ( 0, 0, 0 ) );
               graphics.fillRect( 0, 0, bildbreite, bildhoehe );
               graphics_map.setColor( new Color ( 0, 0, 0 ) );
               graphics_map.fillRect( 0, 0, bildbreite, bildhoehe );
               graphics_alpha.setColor( new Color ( 0, 0, 0 ) );
               graphics_alpha.fillRect( 0, 0, bildbreite, bildhoehe );

               direktion = 0;

               // Fuer jede Spalte
               for( j = 0; j < bildbreite; j++ ) {
                    
                    if( direktion == 0 ) {
                         j_neu = ( bildbreite / 2 ) - j;
                    } else {
                         j_neu = j;
                    }

                    Xs = -( dimx / zoom ) + Xoff + ( j_neu * Stepx );
                    System.out.println( m + "->" + j_neu );
                    value_change = 0;

                    // Fuer jede Zeile
                    for( i = 0; i < bildhoehe; i++ ) {

                         Ys = (dimy / zoom) + Yoff - (i*Stepy);

                         // Fuer jede Tiefe
                         for( k = 0; k < bildtiefe; k++ ) {
                              Zs = Zoff + ( ( bildtiefe - k ) * Stepz ) - ( dimz );
 
                              verkuerzung = 0.5 + ( ( dim / ( ( k + 1 ) * ( dim / bildtiefe2 ) ) ) / 2 );

                              koor[0] = Xs;
                              koor[1] = Ys;
                              koor[2] = Zs;

                              if( k == 0 ) {
                                   pic[j_neu][i] = 0;
                                   pic_map[j_neu][i] = 0;
                              }

                              n = 0;

                              if( pic[j_neu][i] == 0 ) {
                                   if( bulb == false ) {
                                        koor = calcnewkoords( koor, anglez );
                                        n = calc( koor[0], koor[1] );
                                   } else {
                                        koor = calcnewkoords3d( koor, anglez, anglex, angley, verkuerzung );
                                        n = calc3d( koor[0], koor[1], koor[2], phase_step );
                                   }
                              }

                              if( n > 0 ) {
                                   pic_map[j_neu][i] = k;
                                   pic[j_neu][i] = bildtiefe - (int) ( ( koor[2] + dimz - Zoff ) / Stepz );
                                   value_change = 1;

                                   //if(max<pic[i][j]) max=pic[i][j];
                                   //if(min>pic[i][j]) min=pic[i][j];
                                   break;
                                   // erstelle die Farbe dafuer und Zeichne den Punkt
                              }
                         }
                    }
                    if( value_change == 0 ) {
                         direktion++;
                         j = ( bildbreite / 2 );
                    }
                    if( direktion == 2 )
                         break;
               }

// Blau zu Rot
// Rot zu Gruen
// Es gibt nur 4 Farbbereiche
// --> 1024 Farbwerte
// Anzahl von min zu max;
      bereich = 1024 / bildtiefe;
      bereich2 = 256 / bildtiefe;
//      bereich = 1024 / (max - min);
//      bereich = 1;

      for(i=0;i<bildhoehe;i++)
      {
        for(j=0;j<bildbreite;j++)
        {
          if(pic[j][i]>0)
          {
// Bildtiefe gibt Farbe vor
            farb = (double) pic[j][i] * bereich;
            k = (int) farb;

            red = 255;
            green = k%256;;
            blue = 0;

            if(k>255)
            {
              red = 255-(k%256);
              green = 255;
              blue = 0;
            }

            if(k>511)
            {
              red = 0;
              green = 255;
              blue = k%256;
            }

            if(k>767)
            {
              red = 0;
              green = 255-(k%256);
              blue = 255;
            }

            graphics.setColor(new Color (red,green,blue));
            graphics.fillRect(j,i,1,1);
          }

          if(pic_map[j][i]>0)
          {
// Bildtiefe gibt Farbe vor
            farb = (double) pic_map[j][i] * 0.25;
            k = (int) farb;

            red = 255-(k%256);
            green = red;
            blue = red;

            if(k>255)
            {
              red = 255-(k%256);
              green = 0;
              blue = k%256;
           }

//            if(k>511)
//            {
//              red = 255-(k%256);
//              green = 0;
//              blue = k%256;
//            }

//            if(k>767)
//            {
//              red = 255-(k%256);
//              green = 0;
//              blue = 255;
//            }

            graphics_map.setColor(new Color (red,green,blue));
            graphics_map.fillRect(j,i,1,1);
            graphics_alpha.setColor(new Color (255,255,255));
            graphics_alpha.fillRect(j,i,1,1);
          }
        }
      }

      dateiname = String.format("ani/bild_%03d.png",(m+1));
      dateiname_map = String.format("ani/bild_map_%03d.png",(m+1));
      dateiname_alpha = String.format("ani/bild_alpha_%03d.png",(m+1));

      try
      {
        if (ImageIO.write(image,"png",new File (dateiname)) == false)
        {
          System.out.println ("Unbekanntes Zielformat");
          System.exit(1);
        }
      }
      catch (IOException e)
      {
        System.out.println ("Fehler beim Laden oder Speichern!");
        System.exit(1);
      }

      try
      {
        if (ImageIO.write(image_map,"png",new File (dateiname_map)) == false)
        {
          System.out.println ("Unbekanntes Zielformat");
          System.exit(1);
        }
      }
      catch (IOException e)
      {
        System.out.println ("Fehler beim Laden oder Speichern!");
        System.exit(1);
      }
      try
      {
        if (ImageIO.write(image_alpha,"png",new File (dateiname_alpha)) == false)
        {
          System.out.println ("Unbekanntes Zielformat");
          System.exit(1);
        }
      }
      catch (IOException e)
      {
        System.out.println ("Fehler beim Laden oder Speichern!");
        System.exit(1);
      }

//      Picture picture = new Picture (image);
//      picture.setVisible(true);
    }
  }

  public static double[] calcnewkoords(double[] koord,double anglez)
  {
    double Xa,Ya,angle_alt,angle_alt_cos,angle_alt_sin,angle_neu,abstandxy;

    // Berechne den Abstand
    Xa = koord[0];
    Ya = koord[1];

    // Winkel berechnen vom Offset zum aktuellen Punkt
    // 1. Abstand der Punkte
    abstandxy = Math.sqrt(Xa*Xa+Ya*Ya);

    // 2. Winkel vom Offset (Bogenmass)
    angle_alt_sin = Math.asin(Ya / abstandxy);
    angle_alt_cos = Math.acos(Xa / abstandxy);

    if(angle_alt_sin>0)
    {
      angle_alt = angle_alt_cos;
    }
    else
    {
      angle_alt = 0-angle_alt_cos;
    }

    // 3. Neuen Winkel berechnen
    angle_neu = angle_alt + (anglez * Math.PI / 180);
    // 4. Neue Kooridnaten berechnen
    Xa = (Math.cos(angle_neu)*abstandxy);
    Ya = (Math.sin(angle_neu)*abstandxy);

    koord[0] = Xa;
    koord[1] = Ya;

    return koord;
  }

  public static double[] calcnewkoords3d(double[] koord,double anglez, double anglex, double angley, double verkuerzung)
  {
    double Xa,Ya,Za,angle,angle_cos,angle_sin,abstandxy,abstandyz,abstandxz;

    // Berechne den Abstand
    Xa = koord[0];
    Ya = koord[1];
    Za = koord[2];

    // Winkel berechnen vom Offset zum aktuellen Punkt
    // 1. Abstand der Punkte
    abstandxy = Math.sqrt(Xa*Xa+Ya*Ya);

    // 2. Winkel vom Offset (Bogenmass)
    angle_sin = Math.asin(Ya / abstandxy);
    angle_cos = Math.acos(Xa / abstandxy);
//    abstandxy *= verkuerzung;

    angle = 0;
    if(angle_sin>0)
    {
      angle = angle_cos;
    }
    else if(angle_sin<0)

    {
      angle = 0-angle_cos;
    }
    else if(angle_cos>Math.PI/2) angle = Math.PI;

    // 3. Neuen Winkel berechnen
    angle += (anglez * Math.PI / 180);
    // 4. Neue Kooridnaten berechnen
    Xa = (Math.cos(angle)*abstandxy);
    Ya = (Math.sin(angle)*abstandxy);

    abstandyz = Math.sqrt(Ya*Ya+Za*Za);
    angle_sin = Math.asin(Za / abstandyz);
    angle_cos = Math.acos(Ya / abstandyz);

    angle = 0;
    if(angle_sin>0)
    {
      angle = angle_cos;
    }
    else if(angle_sin<0)
    {
      angle = 0-angle_cos;
    }
    else if(angle_cos>Math.PI/2) angle = Math.PI;

    angle += (anglex * Math.PI / 180);
    Ya = (Math.cos(angle)*abstandyz);
    Za = (Math.sin(angle)*abstandyz);

    abstandxz = Math.sqrt(Xa*Xa+Za*Za);
    angle_sin = Math.asin(Za / abstandxz);
    angle_cos = Math.acos(Xa / abstandxz);

    angle = 0;
    if(angle_sin>0)
    {
      angle = angle_cos;
    }
    else if(angle_sin<0)
    {
      angle = 0-angle_cos;
    }
    else if(angle_cos>Math.PI/2) angle = Math.PI;

    angle += (angley * Math.PI / 180);
    Xa = (Math.cos(angle)*abstandxz);
    Za = (Math.sin(angle)*abstandxz);

    koord[0] = Xa;
    koord[1] = Ya;
    koord[2] = Za;

    return koord;
  }

/*
Berechnung, ob der Punkt noch innerhalb oder ausserhalb des Kreises ist
*/
  public static int calc(double Xs, double Ys)
  {
    int n,Anzahl = 1024;
    int Farbverlaeufe = Anzahl / 256;
    double X=0,Y=0,Xt;
    double r;

    for(n=0;n<Anzahl;n++)
    {
      Xt = Math.pow(X,2) - Math.pow(Y,2) + Xs;
      Y = 2 * X * Y + Ys;
      X = Xt;

      // Berechne den Abstand vom Punkt
      r = Math.sqrt(X * X + Y * Y);

      if(r > Farbverlaeufe)
      {
        break;
      }
    }
    return n%256;
  }

     public static int calc3d(double x, double y, double z, double phase_step)
     {
          int n, Anzahl = 16;//4096;
          int Farbverlaeufe = 4;
          double r, theta, phi, phase;

          for( n = 0; n < Anzahl; n++ )
          {
               r = Math.sqrt( x * x + y * y + z * z );

               if( r > Farbverlaeufe )
               {
                    return 0;
               }

//               theta = Math.atan2(Math.sqrt(x*x + y*y) , z) * 8;
//               phi = Math.atan2(y,x) * 8;
//               x += Math.pow(r,8) * Math.sin(theta) * Math.cos(phi);
//               y += Math.pow(r,8) * Math.sin(theta) * Math.sin(phi);
//               z += Math.pow(r,8) * Math.cos(theta);

               phase = Math.PI * phase_step / 128;

               theta = Math.atan2( y ,x ) * 8;
               phi = Math.asin( z / r ) * 8 + phase;

               x += Math.pow( r, 8 ) * Math.cos( theta ) * Math.cos( phi );
               y += Math.pow( r, 8 ) * Math.sin( theta ) * Math.cos( phi );
               z += Math.pow( r, 8 ) * Math.sin( phi );
          }
          return 1;
     }

  public static void main(String[] args)
  {
    Mandelbrot(Integer.parseInt(args[0]), Integer.parseInt(args[1]), Double.parseDouble(args[2]), Double.parseDouble(args[3]), Double.parseDouble(args[4]), Double.parseDouble(args[5]), Double.parseDouble(args[6]), Boolean.parseBoolean(args[7]), Double.parseDouble(args[8]), Double.parseDouble(args[9]), Double.parseDouble(args[10]), Integer.parseInt(args[11]), Integer.parseInt(args[12]), Integer.parseInt(args[13]));
//    Mandelbrot(768, 0.5625, 1.25, 1, 0, 0, 0, true, 1.25, 17, 25);
  }
  // Ende Methoden
}
Comments: