Fractals recursivas: Sierpinski [JAVA]

Vimos um primeiro programa chamado “DrawWorld” que introduziu os gráficos orientados de programação Java. Vamos mudar este programa básico para gerar um recursivo fractal básico: O Sierpinski.

(Ver e geração de um fractal recursiva)

É um fractal que é construído de forma recursiva a partir de um triângulo cujos lados são divididos por seu ponto médio. Com estes novos pontos, e anterior, novos triângulos são construídos semelhante ao anterior.

Se partimos de um triângulo ABC e obter os pontos médios de seus lados (MNP), o próximo nível de recursão vai construir os três triângulos inferiores: APN, PBM o NMC.

O triângulo Sierpinsky tem um dimensão fractal de Hausdorff-Besicovitch coincidente com a dimensão fractal homotecia igual: 1,58496… (W)

Se cada um destes novos triângulos são subdivididas em três, vamos estar recebendo uma nova figura de forma recursiva. Teremos um novo nível de recursão podemos controlar usando uma variável (nivel_de_recursividad) do nosso programa.

Nós definimos uma função “paintRecursivo” (I chamado a partir do método “pintar”) altura em que baseamos triângulo, ea recursão. A função calcula os vértices do triângulo, pinta a figura e chama-se três vezes, um para cada um dos subtriangles.

Em cada chamada à função reduz o valor da recursão, de modo que, quando é concluída a zero levando recursão.

importar java.applet.Applet;
importar java.awt.Graphics;
/**
* @ Autor José Juan Aliaga
*/
público classe MainApp estende-se Applet {
 dobrar xp1 = 300;
 dobrar YP1 = 300;
 dobrar XP2 = 10;
 dobrar yp2 = 300;
 dobrar sin60 = Math.sin(3.14/3.);
 int nivel_de_recursividad = 6;

 público MainApp() { }

 público estático invalidar principal(Corda[] args) { }

 public void pintar(Graphics g){
   paintRecursivo(g,nivel_de_recursividad,xp1, YP1, XP2, yp2);
 }

 private void paintRecursivo(Graphics g, int Eu, dobrar xp12, dobrar yp12, dobrar Xp22, dobrar yp22 ) {

 dobrar dx =(Xp22-xp12)/2.;
  dobrar dois =(yp22-yp12)/2.;
  dobrar XP32 xp12   dx = 2 * valor * sin60;
  dobrar yp32=yp12 dy 2*dx*sin60;

  dobrar dx1 =(Xp22   xp12)/2.;
  dobrar DY1 =(yp22   yp12)/2.;
  dobrar dx2 =(XP32   Xp22)/2.;
  dobrar DY2 =(yp32   yp22)/2.;
  dobrar dx3 =(xp12   XP32)/2.;
  dobrar DY3 =(yp12   yp32)/2.;

  se(Eu<= 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);
  }
  outro{
   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 recursivas : Curva de Koch

Curso JAVA