Graficación y Multimedia Izyalyth Alvarez Cisneros 1

Universidad Politécnica de

Tecámac

Carrera: Ing. En Software

Grupo: 2614IS

Alumno: Alvarez Cisneros Izyalyth Ernestina

Materia: Graficación y Multimedia

Titulo:

Triángulo de Sierpinski

Profesor: Fausto Zarate Melchor

14 - Mayo - 2014

Graficación y Multimedia Izyalyth Alvarez Cisneros 2

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.

Graficación y Multimedia Izyalyth Alvarez Cisneros 3

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:

Graficación y Multimedia Izyalyth Alvarez Cisneros 4

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.

Graficación y Multimedia Izyalyth Alvarez Cisneros 5

Código en C#: REPRODUCCION:

(Davidson, Steven R. Curso de Gráficos. 2004-06-07 Sitio Web: http://graficos.conclase.net/curso/?cap=003c#)

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);

}

}

}

}