Fractals ricorsive: Sierpinski triangolo [JAVA]

Abbiamo visto un primo programma chiamato “DrawWorld” abbiamo introdotto la grafica orientata programmazione Java. Cambiamo questo programma di base per generare un frattale di base ricorsiva: Gli Sierpinski triangolo.

(Vedere e la generazione di un frattale ricorsiva)

È un frattale che è costruito ricorsivamente da un triangolo i cui lati sono divise da suo punto medio. Con questi nuovi punti, e precedenti, nuovi triangoli sono costruiti simile alla precedente.

Se si parte da un triangolo ABC e ottenere i punti medi dei suoi lati (MNP), il prossimo livello di ricorsione costruirà i tre triangoli inferiori: APN, PBM l'NMC.

Il triangolo di Sierpinski ha un dimensione frattale di Hausdorff-Besicovitch coincidente con la dimensione frattale homotecia pari a: 1,58496… (Gli)

Se ognuno di questi nuovi triangoli sono suddivise in tre, ci sarà sempre una nuova figura in modo ricorsivo. Avremo un nuovo livello di ricorsione possiamo controllare utilizzando una variabile (nivel_de_recursividad) del nostro programma.

Abbiamo definito una funzione “paintRecursivo” (Ho chiamato dal metodo “dipingere”) a che punto siamo di base del triangolo, e la ricorsione. La funzione calcola i vertici del triangolo, dipinge la figura e si chiama tre volte, uno per ciascuno dei subtriangles.

In ogni chiamata alla funzione riduce il valore della ricorsione, in modo che quando si tratta di finiture a zero portando ricorsione.

importare java.applet.Applet;
importare java.awt.Graphics;
/**
* @ Autore José Juan Aliaga
*/
pubblico classe MainApp estende Applet {
 raddoppiare XP1 = 300;
 raddoppiare YP1 = 300;
 raddoppiare XP2 = 10;
 raddoppiare yp2 = 300;
 raddoppiare sin60 = Math.sin(3.14/3.);
 int nivel_de_recursividad = 6;

 pubblico MainApp() { }

 pubblico statica invalidare principale(Stringa[] args) { }

 public void dipingere(Graphics g){
   paintRecursivo(g,nivel_de_recursividad,XP1, YP1, XP2, yp2);
 }

 private void paintRecursivo(Graphics g, int i, raddoppiare XP12, raddoppiare yp12, raddoppiare Xp22, raddoppiare yp22 ) {

 raddoppiare dx =(Xp22-XP12)/2.;
  raddoppiare due =(yp22-yp12)/2.;
  raddoppiare XP32 XP12   dx = 2 * valore * sin60;
  raddoppiare yp32=yp12 dy 2*dx*sin60;

  raddoppiare dx1 =(Xp22   XP12)/2.;
  raddoppiare DY1 =(yp22   yp12)/2.;
  raddoppiare dx2 =(XP32   Xp22)/2.;
  raddoppiare dy2 =(yp32   yp22)/2.;
  raddoppiare DX3 =(XP12   XP32)/2.;
  raddoppiare DY3 =(yp12   yp32)/2.;

  se(i<= 0){
   g.drawLine((int)XP12,(int)yp12,(int)Xp22,(int)yp22);
   g.drawLine((int)Xp22,(int)yp22,(int)XP32,(int)yp32);
   g.drawLine((int)XP32,(int)yp32,(int)XP12,(int)yp12);
  }
  altro{
   paintRecursivo(g,i-1, XP12, yp12, dx1, dy1);
   paintRecursivo(g,i-1, dx1, dy1, Xp22, yp22);
   paintRecursivo(g,i-1, DX3, DY3, DX2, dy2);
  }

 }
}

• Fractals ricorsive : Curva di Koch

Corso JAVA