Fractales: Triángulo de Sierpinski

El segundo ejemplo de fractales que veremos es el triángulo de Sierpinski. Este triángulo también se basa en un método recursivo, como el ejemplo anterior. Comenzamos con un triángulo equilátero, como muestra la imagen de la Figura 1.

[IMAGEN]: Figura 1 - Sierpinski n=0
Figura 1 - Sierpinski n=0

En cada pasada, dividimos 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 estamos dividiendo. Con la mitad de longitud, el área de cada subtriángulo es un cuarto del original. Por lo tanto, podemos rellenar el triángulo original con cuatro triángulos pequeños. En el fractal de Sierpinski, sólo nos interesamos 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.

[IMAGEN]: Figura 2 - Sierpinski n=1
Figura 2 - Sierpinski n=1

Con la tercera pasada, dividimos cada subtriángulo como si fuera el original. De nuevo obtenemos 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.

[IMAGEN]: Figura 3 - Sierpinski n=2
Figura 3 - Sierpinski n=2

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:

Iniciar_Sierpinski()
  1. Declarar: A, B, y C como puntos
  2. Inicializar: A, B, y C
  3. Dibujar_Sierpinski( A, B, C, Número_Iteraciones )
  4. Terminar

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

Para Dibujar_Sierpinski(), el algoritmo es:

Dibujar_Sierpinski( A, B, C, N )
  1. Si N = 0 entonces, // Triángulo Mínimo
  2. Dibujar_Triángulo_Relleno( A, B, C )
  3. Terminar
  4. Si no, entonces, // Dividir en 3 triángulos
  5. AB ← Mitad( A, B )
  6. BC ← Mitad( B, C )
  7. CA ← Mitad( C, A )
  8. Dibujar_Sierpinski( A, AB, CA, N-1 )
  9. Dibujar_Sierpinski( AB, B, BC, N-1 )
  10. Dibujar_Sierpinski( CA, BC, C, N-1 )
  11. Terminar

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:

Real Mitad( P1, P2 )
  1. Resultado.x ← (P1.x + P2.x) / 2
  2. Resultado.y ← (P1.y + P2.y) / 2
  3. Terminar( Resultado )

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.

Observaciones

Como sucedió con la curva de Koch, podemos usar directamente los valores de los píxeles para describir los vértices del triángulo. Sin embargo, como los píxeles deben ser valores enteros, no podemos guardarlos como tales en A, B, y C. Si lo hiciéramos, entonces perderíamos información al ser truncada la parte decimal. Esto implicaría que la imagen contendría errores visibles: los lados de los triángulos no son tan rectos, especialmente al repetir muchas veces: n > 1. Para evitar este efecto, guardamos los píxeles en A, B, y C como valores decimales. En el momento de dibujar el triángulo, debemos convertir tales valores decimales a enteros usando cualquier método de redondeo. De esta forma, sólo truncamos los valores en el momento propicio (al dibujar un triángulo), pero manteniendo la información y así no producir errores de aproximación.

En el algoritmo anterior, no hemos tenido en cuenta la orientación del eje-Y de la pantalla (en píxeles), esto es porque hemos usado píxeles directamente. Por lo tanto, estamos calculando y dibujando en el mismo plano: la pantalla o píxeles. Esto implica que no necesitamos realizar ningún tipo de conversión o cambio de coordenadas.

Explicación Detallada

Para aquellos lectores que les interese conocer más acerca de las matemáticas relacionadas con estos conceptos, expondremos una explicación acerca de este fractal. La dimensión de capacidad para el triángulo de Sierpinski se basa en la longitud y número de triángulos pintados de cada iteración.

Dejemos que Nn sea el número de triángulos, según la iteración n, y Ln, la longitud de cada lado, según la iteración n.

N0 = 1,     (Imagen de la Figura 1)
N1 = 3,     (Imagen de la Figura 2)
N2 = 9,     (Imagen de la Figura 3)
N3 = 27,
.
.
.
Nn = 3n,

L0 = 1,     (Imagen de la Figura 1)
L1 = 1/2,   (Imagen de la Figura 2)
L2 = 1/4,   (Imagen de la Figura 3)
L3 = 1/8,
.
.
.
Ln = 1/2n = 2-n

El cálculo de la dimensión de la capacidad, dcap, es:

                   ln Nn                ln 3n                 n * ln 3
dcap = - lim n→∞ ------ = - lim n→∞ ------- = - lim n→∞ ----------- =
                   ln Ln                ln 2-n               -n * ln 2
                  
                 ln 3     ln 3
     = lim n→∞ ------ = ------ = 1,584962501...
                 ln 2     ln 2

(Nota: ∞ se refiere al concepto matemático de "infinito").

El triángulo de Sierpinski comienza como un objeto de dos dimensiones; o sea, una superficie. En cada iteración, se le "agregan" agujeros al triángulo. Llevado a infinito, obtenemos más agujeros que superficie, hasta quedarnos con un objeto de líneas rectas. Sin embargo, una línea recta es un objeto unidimensional. Es decir, hemos ido de un objeto 2D a un objeto 1D. La pregunta principal es ¿qué dimensión tiene este objeto? Según hemos visto, la dimensión debe quedar entre 1 y 2 dimensiones. Esta idea conlleva a la idea de una dimensión fraccional. En el caso del triángulo de Sierpinski, obtenemos una dimensión aproximada de 1,6, que efectivamente queda dentro de nuestro intervalo de 1 y 2 dimensiones.

Para dar un ejemplo, como explicación, imaginaos que tenemos un queso suizo con más agujeros que queso, hasta tal punto que tenemos un hilo de queso, pero todo agujero.

Ejercicios

Enlace al paquete de este capítulo.

  1. Escriba un programa que dibuje el triángulo de Sierpinski. Se puede usar el algoritmo presentado en este capítulo. Use las siguientes restricciones y condiciones iniciales:
    Resolución: 500 x 500.
    Calcule, con N=5 iteraciones.
  2. El triángulo de Sierpinski no tiene por qué ser equilátero. Construya el triángulo de Sierpinski para cada triángulo descrito por sus vértices, use las siguientes restricciones:
    Resolución: 500 x 500
    Calcule, con N=4 iteraciones.
    1. A = (0, 0), B = (499, 499), y C = (0, 499);
    2. A = (250, 0), B = (375, 499), y C = (125, 499);
    3. A = (300, 50), B = (400, 400), y C = (10, 200);
  3. Escriba el triángulo de Sierpinski, pero ahora se perturbará los vértices. Cada vez que se calculen los puntos medios para cada subtriángulo, se agregará un valor aleatorio en una orientación aleatoria. La forma más sencilla de hacer esto es seleccionando un intervalo para la perturbación. Por ejemplo, elegimos un intervalo de 5 píxeles. Necesitamos generar números aleatorios entre -2 y +2. Si por casualidad generamos el valor 0 (cero), entonces no realizamos ninguna perturbación. Las perturbaciones se deberán hacer en ambas direcciones: eje-X y eje-Y. Para una coordenada (x, y) agregamos dos valores aleatorios, a y b, a cada elemento, obteniendo (x+a, y+b).
  4. En lugar de usar triángulos, podemos usar cuadrados. Comenzamos con un cuadrado como figura original. En la primera iteración, dividimos nuestro cuadrado original en 9 cuadrados más pequeños de igual tamaño. El cuadrado central está vacío y queda como agujero, mientras que los demás son rellenados formando un borde. En las demás iteraciones, cada subcuadrado es sometido al mismo proceso. A este fractal se le denomina Alfombra de Sierpinski. La siguiente figura puede servir de ejemplo:

    [IMAGEN]: Alfombra de Sierpinski N=[0,4]
    Alfombra de Sierpinski N=[0,4]
    Escriba un programa para representar la alfombra de Sierpinski con las siguientes restricciones y valores iniciales:
    Resolución: 500 x 500.
    Calcule, con N=4 iteraciones.

Comentarios de los usuarios (1)

guillermo
2019-11-18 11:51:35

PUNTO2 A={50,100},B={80,100},C={100,150};

TrianguloRelleno(A, B , C);

hola Steven R. Davidson lo consegui de esta forma