TRIÁNGULO DE SIERPINSKI

Prácticamente es un FRACTAL viene de "dimensión fraccional" – en inglés, fraccional dimensión. La definición de un fractal es un objeto o cantidad que muestra auto-semejanza para todas las escalas. El objeto no tiene por qué demostrar la misma estructura en todas las escalas, pero sí el mismo tipo de estructura. Para que los lectores se hagan una idea, piensen que la longitud de un fractal es la longitud del borde (o la "costa") medida con reglas de diferentes longitudes. Cuanto más corta sea la regla, más grande es la longitud medida. Esta conclusión es conocida como la paradoja de la costa.

 Este triángulo también se basa en un método recursivo. Que comienza con  un triángulo equilátero, como muestra la imagen de la Figura 1.

En cada pasada, se divide  el triángulo en tres triángulos más pequeños. Los lados de cada "sub-triángulo" equilátero tienen la mitad de longitud que los del triángulo original, el cual se dividió. Con la mitad de longitud, el área de cada subtriángulo es un cuarto del original. Por lo tanto, se puede  rellenar el triángulo original con cuatro triángulos pequeños. En el fractal de Sierpinski, sólo lo representaremos con  tres subtriángulos, por lo que el triángulo invertido en el centro es realmente un "agujero". Esto se observa más claramente en la Figura 2.

Con la tercera pasada, se divide cada subtriángulo como si fuera el original. De nuevo se obtienen  tres triángulos más pequeños y un agujero en el centro. El total será de nueve triángulos y cuatro agujeros. Esto se percibe más claramente en la Figura 3.

Nuevamente, podemos observar el elemento recursivo en este fractal, para generar el triángulo de Sierpinski. Comenzamos con tres puntos (A, B, y C) formando las coordenadas de los vértices del triángulo original. Luego, la función recursiva averiguará la mitad de cada lado (AB, BC, y CA) usando los vértices. El orden para subdividir cada triángulo es irrelevante: el izquierdo, el derecho, y luego el superior, o cualquier orden que se quiera seguir.

ALGORITMO

El algoritmo para dibujar el triángulo de Sierpinski se puede separar en dos partes principales. La primera parte, Iniciar_Sierpinski(), es sencillamente la invocación a la función recursiva, Dibujar_Sierpinski(). La segunda parte es el algoritmo de la función recursiva en sí, Dibujar_Sierpinski().

Para Iniciar_Sierpinski(), el algoritmo es:

A, B, y C son los vértices del triángulo original.

Para Dibujar_Sierpinski(), el algoritmo es:

A, B, y C son los vértices del triángulo o subtriángulo.

N es el número de iteraciones.

Para Mitad(), el algoritmo es:

En el algoritmo, no dibujamos nada hasta llegar al triángulo más pequeño; o sea, N = 0. En los otros niveles de profundidad, N > 0, sólo dividimos cada lado en tres triángulos más pequeños y calculamos las dimensiones de cada subtriángulo.

La función Dibujar_Triángulo_Relleno() hace referencia a una función de la biblioteca o API gráfica para dibujar un triángulo según las vértices dadas en orden. Esto es, se trazan las líneas del primer vértice al segundo (A→B), del segundo al tercero (B→C), y del tercero al primero (C→A). El triángulo es dibujado y rellenado con los colores previamente establecidos.

Código en C#:

using System; using System.Drawing;

namespace Sierpinsky

 {

unsafe class Sierpinski

 { public Graphics Draw(Graphics g, int ancho, int alto)

 { Graphics g0 = g; Point* esq = stackalloc Point[3]; esq[0].X = 50; esq[0].Y = alto - 10; esq[1].X = ancho - 10; esq[1].Y = alto - 10; esq[2].X = ancho / 2; esq[2].Y = 10; Sierp(g0, esq, 0); g = g0; return g; }

 private void Sierp(Graphics g0, Point* p, int n)

 { Pen pen = new Pen(Color.Black, 1); g0.DrawLine(pen, p[0], p[1]); g0.DrawLine(pen, p[1], p[2]); g0.DrawLine(pen, p[2], p[0]); Point* p2 = stackalloc Point[3]; if (n<7)

{

p2[0].X = (p[0].X + p[1].X) / 2 + (p[1].X - p[2].X) / 2; p2[0].Y = (p[0].Y + p[1].Y) / 2 + (p[1].Y - p[2].Y) / 2; p2[1].X = (p[0].X + p[1].X) / 2 + (p[0].X - p[2].X) / 2; p2[1].Y = (p[0].Y + p[1].Y) / 2 + (p[0].Y - p[2].Y) / 2; p2[2].X = (p[0].X + p[1].X) / 2; p2[2].Y = (p[0].Y + p[1].Y) / 2;

Sierp(g0, p2, n+1); p2[0].X = (p[1].X + p[2].X) / 2 + (p[1].X - p[0].X) / 2; p2[0].Y = (p[1].Y + p[2].Y) / 2 + (p[1].Y - p[0].Y) / 2; p2[1].X = (p[1].X + p[2].X) / 2 + (p[2].X - p[0].X) / 2; p2[1].Y = (p[1].Y + p[2].Y) / 2 + (p[2].Y - p[0].Y) / 2; p2[2].X = (p[1].X + p[2].X) / 2; p2[2].Y = (p[1].Y + p[2].Y) / 2;

 Sierp(g0, p2, n+1); p2[0].X = (p[0].X + p[2].X) / 2 + (p[2].X - p[1].X) / 2; p2[0].Y = (p[0].Y + p[2].Y) / 2 + (p[2].Y - p[1].Y) / 2; p2[1].X = (p[0].X + p[2].X) / 2 + (p[0].X - p[1].X) / 2; p2[1].Y = (p[0].Y + p[2].Y) / 2 + (p[0].Y - p[1].Y) / 2; p2[2].X = (p[0].X + p[2].X) / 2; p2[2].Y = (p[0].Y + p[2].Y) / 2;

Sierp(g0, p2, n + 1);

       }

     }

   }

 }

REPRODUCCION:

 (Davidson, Steven R. Curso de Gráficos. 2004-06-07

Sitio Web: http://graficos.conclase.net/curso/?cap=003c#)