Fractales recursivos: Triángulo de Sierpinski [JAVA]

Hemos visto un primer programa denominado “DrawWorld” que nos introducía la programación en JAVA orientada a los gráficos. Veamos como modificar este programa elemental para generar un fractal recursivo básico: El triángulo de Sierpinski.

(Ver como se genera un fractal recursivo)

Es un fractal que se construye de forma recursiva a partir de un triángulo cuyos lados se dividen por su punto medio. Con estos nuevos puntos, y los anteriores, se construyen nuevos triángulos semejantes al anterior.

Si partimos de un triángulo ABC y obtenemos los puntos medios de sus lados (MNP), el siguiente nivel de recursividad se obtendrá construyendo los tres triángulos siguientes: APN, PBM y NMC.

El triángulo de Sierpinski tiene una dimensión fractal de Hausdorff-Besicovitch coincidente con su dimensión fractal de homotecia igual a: 1,58496… (W)

Si cada uno de estos nuevos triángulos se divide a su vez en tres, estaremos obteniendo una nueva figura de forma recursiva. Tendremos un nuevo nivel de recursividad que podemos controlar mediante una variable (nivel_de_recursividad) de nuestro programa.

Se ha definido una función “paintRecursivo” (que se llama desde el método “paint”) a la que pasamos los puntos de la base del triángulo, así como el nivel de recursividad. La función calcula los vértices del triángulo, pinta la figura y se llama a sí misma tres veces, una para cada uno de los subtriángulos.

En cada llamada a la función se reduce el valor de recursividad, de forma que cuando éste es cero termina de efectuar la recursividad.

import java.applet.Applet;
import java.awt.Graphics;
/**
* @author José Juan Aliaga
*/
public class MainApp extends Applet {
 double xp1=300;
 double yp1=300;
 double xp2=10;
 double yp2=300;
 double sin60=Math.sin(3.14/3.);
 int nivel_de_recursividad=6;

 public MainApp() { }

 public static void main(String[] args) { }

 public void paint(Graphics g){
   paintRecursivo(g,nivel_de_recursividad,xp1,yp1,xp2,yp2);
 }

 private void paintRecursivo(Graphics g, int i, double xp12, double yp12, double xp22, double yp22 ) {

 double dx=(xp22-xp12)/2.;
  double dy=(yp22-yp12)/2.;
  double xp32=xp12+dx-2*dy*sin60;
  double yp32=yp12+dy+2*dx*sin60;

  double dx1=(xp22+xp12)/2.;
  double dy1=(yp22+yp12)/2.;
  double dx2=(xp32+xp22)/2.;
  double dy2=(yp32+yp22)/2.;
  double dx3=(xp12+xp32)/2.;
  double dy3=(yp12+yp32)/2.;

  if(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);
  }
  else{
   paintRecursivo(g,i-1,xp12,yp12,dx1,dy1);
   paintRecursivo(g,i-1,dx1,dy1,xp22,yp22);
   paintRecursivo(g,i-1,dx3,dy3,dx2,dy2);
  }

 }
}

• Fractales recursivos : Curva de Koch

Curso JAVA