from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import math as math
import matplotlib.patches as mpatches
from math import sin, cos, pi, atan2
from pylab import *
import random
print ("Fractales")
while True:
print("Opción 1- Función WeiersTrass")
print("Opción 2- El conjunto de Cantor")
print("Opción 3- El conjunto de Julia")
print("Opción 4- El triángulo de Sierpinski")
print("Opción 5- La curva de Koch")
print("Opción 6- La curva del dragón")
print("Opción 7- La curva de Levy C")
print("Opción 8- Fractales en la naturaleza")
print("Opción 9- Referencias")
print("Opción 10- Terminar ciclo")
opción=int(input("Elija una opción: "))
if opción==1:
print()
print ("Función Weierstrass")
print ("Esta función es definida como f(x)=Σa^n*cos(b^n*π*x), desde n=0 hasta infinito, donde 0<a<1, b es un entero impar y positivo y cumplen que a*b<1+3/2*π")
MyVar = 100000
startbee=-2
stopbee=2
bee = np.arange(startbee,stopbee,((stopbee-startbee)/MyVar))
def weierstrass(x,Nvar):
we=np.zeros(MyVar)
for n in range(0,Nvar):
we=we+np.cos(3**n*np.pi*x)/2**n
return we
plt.plot(bee,np.reshape(weierstrass(bee, 500),(MyVar,)))
plt.title("Función Weierstrass")
plt.axhline(0,color="Black")
plt.axvline(0,color="Black")
plt.show()
print ()
elif opción==2:
print ()
print ("Conjunto de Cantor")
class Ci:
def Grafica (self, pi, pf, nivel):
x = [pi,pf]
y = [1/nivel, 1/nivel]
plt.plot (x,y, linewidth=2, color="blue")
plt.title("Conjunto de Cantor con intervalos de longitud (1/3)^k")
puntos = []
incre = (1/3) ** nivel
puntos.append([pi, pi+incre])
puntos.append([pf-incre, pf])
return puntos
def Dibuja (self,nivel):
puntos = []
puntos.append([0,1])
for i in range(nivel):
nvsP = []
for pdz in puntos:
nvsP.extend(self.Grafica(pdz[0], pdz[1], i+1))
puntos = nvsP
plt.show()
cnt = Ci()
cnt.Dibuja(int(input("La cantidad de veces de división del conjunto: ")))
elif opción==3:
print()
print("¿Qué es el conjunto de Julia")
print("Los conjuntos de Julia, así llamados por el matemático Gaston Julia, son una familia de conjuntos fractales que se obtienen al estudiar el comportamiento de los números complejos al ser iterados por una función holomorfa. El conjunto de Julia de una función holomorfa f está construido por aquellos puntos que bajo la iteración de f tienen comportamiento “caótico”. El conjunto se denota J(f).")
print()
print("Construcción")
print("Se obtiene a partir de funciones cuadráticas simples,como por ejemplo: Fc(z) = z2 + c")
print("C es el conjunto de los números complejos. Supongamos la función ϕ : C → C dada por ϕ(z) = z2 + c (donde c es un número complejo). El conjunto de Julia que se obtiene a partir de esta función y se denota Jc.")
print("La función ϕ tiene como inversa f, definida por: z = z2 + c ⇒ z − c = z2 ⇒ ±√z − c = f(z),sabemos que un n´umero complejo tiene dos raíces cuadradas (excepto el cero), por lo tanto f tiene dos inversas: f0 = √z − c, f1 = −√z − c.")
print("El conjunto de Julia en este caso es un conjunto compacto (cerrado y acotado) y no vacío, tal que J ⊆ C, que satisface: J = f0[J] ∪ f1[J].")
print("Entonces: Jn+1 = f0[Jn] ∪ f1[Jn].")
print("El límite de Jn es J.")
print()
print("Ejemplos")
imagen = Image.open("Julia.png")
plt.imshow(imagen)
plt.axis('off')
plt.show()
print()
elif opción==4:
print()
print("¿Qué es el triángulo de Sierpinski?")
print("Se trata de un fractal descrito por Waclaw Sierpínski en 1915, que ya había aparecido en el arte italiano en el siglo XIII.")
print()
print("Construción")
print("Para generar la figura partimos de un triángulo sólido cualquiera, en nuestro caso equilátero. Éste se divide en cuatro triángulos iguales más pequeños, utilizando para ello el punto medio de cada lado como nuevo vértice")
print("Finalmente eliminamos el triángulo que queda en el medio. Este proceso se repite en cada uno de los triángulos restantes.")
def get_triangle(P):
m = P * 0.5
n = P * 0.5 + np.array([0.5, 0])
k = P * 0.5 + np.array([0.25, np.sqrt(3)/4])
return np.array([m,n,k])
triangle = np.array([[0, 0],[1, 0],[0.5, np.sqrt(3)/2]])
etapa = int(input("¿Hasta qué iteración quieres dibujar?: "))
for e in range(etapa):
triangle = get_triangle(triangle)
fig1 = plt.figure()
ax1 = fig1.add_subplot(111, aspect='equal')
for t in triangle.reshape(3**etapa,3,2):
ax1.add_patch(mpatches.Polygon(t, fc="y"))
plt.title("Ejemplo de un triángulo de sierpinski")
plt.show()
elif opción==5:
print()
print("¿Qué es la curva de Koch?" )
print("El copo de nieve de Koch, también llamado estrella de Koch o isla de Koch, es una curva cerrada continua pero no diferenciable en ningún punto descrita por el matemático sueco Helge von Koch en 1904 en un artículo titulado «Acerca de una curva continua que no posee tangentes y obtenida por los métodos de la geometría elemental».")
print()
print("Construcción")
print("El primer conjunto L0 se construye a partir de un segmento.")
print("Para construir el conjunto L1, dividimos el conjunto L0 en tres partes iguales y reemplazamos la parte central por dos partes de la misma longitud formando un ángulo de 60, de este modo obtenemos el conjunto L1")
print("Para la siguiente iteración dividimos cada uno de los segmentos resultantes en L1 en tres partes iguales y reemplazamos la parte central por dos partes de la misma longitud formando un ángulo de 60 , tal y como se realizó en la iteración de L0 a L1, lo que da lugar a 16 segmentos más pequeños, formando el conjunto L2.")
print("Aplicando el procedimiento anterior k veces obtenemos la curva de Koch.")
def copoVonKoch(lado, n):
x_vertice1 = 0
y_vertice1 = 0
x_vertice2 = lado * cos(2 * pi / 3)
y_vertice2 = lado * sin(2 * pi / 3)
x_vertice3 = lado * cos(pi / 3)
y_vertice3 = lado * sin(pi / 3)
curvaVonKoch(x_vertice1, y_vertice1, x_vertice2, y_vertice2, n)
curvaVonKoch(x_vertice2, y_vertice2, x_vertice3, y_vertice3, n)
curvaVonKoch(x_vertice3, y_vertice3, x_vertice1, y_vertice1, n)
def curvaVonKoch(xi, yi, xf, yf, n):
if n == 0:
plot([xi, xf], [yi, yf], lw=1.0, color='b')
elif n > 0:
x1 = xi + (xf - xi) / 3.0
y1 = yi + (yf - yi) / 3.0
x3 = xf - (xf - xi) / 3.0
y3 = yf - (yf - yi) / 3.0
radio = hypot(x3 - x1, y3 - y1)
alpha = atan2((y3 - y1), (x3 - x1))
alpha += pi / 3.0
x2 = x1 + radio * cos(alpha)
y2 = y1 + radio * sin(alpha)
curvaVonKoch(xi, yi, x1, y1, n - 1)
curvaVonKoch(x1, y1, x2, y2, n - 1)
curvaVonKoch(x2, y2, x3, y3, n - 1)
curvaVonKoch(x3, y3, xf, yf, n - 1)
def dibuja(lado, n):
axes().set_xlim(0, lado)
axes().set_ylim(-2, lado / 2.0)
axes().set_aspect(1.0)
title('Curva De Von Koch')
xlim(0, lado)
curvaVonKoch(0, 0, lado, 0, n)
show()
axes().set_xlim(-lado, lado)
axes().set_ylim(-2, lado + 0.5 * lado)
axes().set_aspect(1.0)
title('Copo De Nieve De Koch')
xlim(-lado, lado)
copoVonKoch(lado, n)
show()
def principal():
print ()
n = int(input('¿Hasta qué iteración quieres dibujar? '))
lado = float(input('Indica la longitud del lado inicial. '))
dibuja(lado, n)
if __name__ == "__main__":
principal()
elif opción==6:
print()
print("¿Qué es la curva del dragón?")
print("Una curva de dragón es cualquier miembro de una familia de curvas fractales autosimilares, que pueden aproximarse mediante métodos recursivos como sistemas-L. También es conocida como la forma que se genera al doblar repetidamente una tira de papel por la mitad, aunque hay otras curvas que también se denominan de forma general curvas de dragón que se generan de manera diferente.")
print()
print("Construcción")
print("Partimos de un segmento de longitud 1 (aunque puede tener cualquier longitud), el cual llamaremos conjunto D0.")
print("Para construir el conjunto D1, utilizaremos el conjunto D0. En dicho conjunto D0 construiremos un triángulo rectángulo e isósceles, eliminamos el segmento inicial del conjunto D0 obteniendo el conjunto D1.")
print("Para construir el conjunto D2 aplicamos el razonamiento anterior, en cada segmento del conjunto D1 construimos un triángulo rectángulo e isósceles, eliminamos los segmentos iniciales del conjunto D1 obteniendo el conjunto D2.")
print("Para construir el conjunto D3 aplicamos el razonamiento anterior, en cada segmento del conjunto D2 construimos un triángulo rectángulo e isósceles, la orientación de cada uno de los triángulos ha de ser alterna, eliminamos los segmentos iniciales del conjunto D2 obteniendo el conjunto D3")
imagen = Image.open("dragon.png")
plt.imshow(imagen)
plt.axis('off')
plt.show()
print()
elif opción==7:
print()
print("¿Qué es la curva de Levy C")
print("la curva de Lévy C es un fractal autosimilar. Descrita por primera vez por Ernesto Cesàro en 1906 y G. Farber en 1910, hoy lleva el nombre del matemático francés Paul Pierre Lévy quien, en 1938, fue el primero en exhibir sus propiedades de autosimilitud y proveer una construcción geométrica.")
print()
print("Contrucción")
print("Utilizando un sistema de Lindenmayer, la construcción de la curva de Lévy C parte de un segmento de recta, este segmento se toma por la hipotenusa de un triángulo rectángulo isósceles, y se reemplaza por los dos catetos de dicho triángulo. De este modo, en esta etapa la curva consiste únicamente de dos segmentos de recta perpendiculares.")
print("En la etapa siguiente, los dos segmentos son tomados como las hipotenusas de dos triángulos rectángulos isósceles, y se les reemplaza por los dos catetos correspondientes, y así sucesivamente.")
print("Después de n etapas, la curva consistirá de 2n segmentos de recta, cada uno de longitud 2n/2 con respecto al segmento de partida.")
print("El sistema de Lindenmayer asociado puede describirse entonces del siguiente modo:")
print("Variables: F")
print("Constantes: + −")
print("Inicio: F")
print("Reglas:F → +F−−F+")
print("donde F significa avanza recto, + significa gira a la derecha 45°, y − significa gira a la izquierda 45°. En el límite, el resultado de este proceso infinito es el fractal conocido como curva de Lévy C, dado su parecido con la letra C.")
imagen = Image.open("levy.png")
plt.imshow(imagen)
plt.axis('off')
plt.show()
print()
def levy_c_curve(ax, order, start, end, angle, line_length):
if order == 0:
x = start[0] + line_length * cos(angle)
y = start[1] + line_length * sin(angle)
ax.plot([start[0], x], [start[1], y], color='k')
else:
new_length = line_length / 2
x = start[0] + new_length * cos(angle)
y = start[1] + new_length * sin(angle)
levy_c_curve(ax, order-1, start, (x, y), angle + pi/4, new_length)
x = x + new_length * cos(angle - pi/2)
y = y + new_length * sin(angle - pi/2)
levy_c_curve(ax, order-1, (start[0] + new_length * cos(angle), start[1] + new_length * sin(angle)), (x, y), angle - pi/4, new_length)
def draw_levy_c_curve(order, line_length):
fig, ax = plt.subplots()
start = (0, 0)
angle = 0
levy_c_curve(ax, order, start, (line_length, 0), angle, line_length)
ax.set_aspect('equal', adjustable='datalim')
plt.show()
order = int(input('¿Hasta qué orden lo quieres hacer? '))
line_length = 100
draw_levy_c_curve(order, line_length)
elif opción==8:
print()
print("Fractales en la naturaleza")
print("Los fractales que vimos hasta aquí viven en el mundo idealizado de las Matemáticas, donde es teóricamente posible repetir cada paso de construcción en forma indefinida, o ver un objeto a escalas arbitrariamente pequeñas. Por supuesto, el mundo real no es así, en la realidad, solo encontramos fractales aproximados. Si nos acercamos demasiado a un objeto real, se perderá cualquier auto-similitud, y eventualmente nos encontraremos con una estructura molecular o atómica. Sin embargo, puede ser muy útil considerar los objetos naturales como fractales si exhiben irregularidades o auto-similitudes cuando se ven en un rango significativo de escalas.")
print()
print("Ejemplos:")
print()
print("-Ramas de los árboles")
imagen = Image.open("ramas de los arboles.png")
plt.imshow(imagen)
plt.axis('off')
plt.show()
print()
print("-El helecho de Barnsley")
def transformation_1(p):
x = p[0]
y = p[1]
x1 = 0.85 * x + 0.04 * y
y1 = -0.04 * x + 0.85 * y + 1.6
return x1, y1
def transformation_2(p):
x = p[0]
y = p[1]
x1 = 0.2 * x - 0.26 * y
y1 = 0.23 * x + 0.22 * y + 1.6
return x1, y1
def transformation_3(p):
x = p[0]
y = p[1]
x1 = -0.15 * x - 0.28 * y
y1 = 0.26 * x + 0.24 * y + 0.44
return x1, y1
def transformation_4(p):
x = p[0]
y = p[1]
x1 = 0
y1 = 0.16 * y
return x1, y1
def get_index(probability):
r = random.random()
c_probability = 0
sum_probability = []
for p in probability:
c_probability += p
sum_probability.append(c_probability)
for item, sp in enumerate(sum_probability):
if r <= sp:
return item
return len(probability) - 1
def transform(p):
transformations = [transformation_1, transformation_2, transformation_3, transformation_4]
probability = [0.85, 0.07, 0.07, 0.01]
tindex = get_index(probability)
t = transformations[tindex]
x, y = t(p)
return x, y
def draw_fern(n):
x = [0]
y = [0]
x1, y1 = 0, 0
for i in range(n):
x1, y1 = transform((x1, y1))
x.append(x1)
y.append(y1)
return x, y
n = int(input('Introduce el número de puntos: '))
x, y = draw_fern(n)
plt.plot(x, y, 'o')
plt.title('Helecho con {0} puntos'.format(n))
plt.show()
print()
print("-El brócoli romanesco")
imagen = Image.open("brocoli.png")
plt.imshow(imagen)
plt.axis('off')
plt.show()
print()
elif opción==9:
print()
for i in ["-https://diposit.ub.edu/dspace/bitstream/2445/54228/1/memoria.pdf", "-https://es.wikipedia.org/wiki/Funci%C3%B3n_de_Weierstrass", "-https://www.mat.ucm.es/cosasmdg/cdsmdg/modelizaciones/proyectos/proyecto3/solucionac1.htm", "-https://relopezbriega.github.io/blog/2020/03/24/fractales-con-python/","-https://es.wikipedia.org/wiki/Copo_de_nieve_de_Koch","-https://es.wikipedia.org/wiki/Curva_del_drag%C3%B3n","-https://es.wikipedia.org/wiki/Curva_de_L%C3%A9vy_C"," "]:
print(i)
elif opción==10:
print("Ciclo terminado")
break
else:
print ("Opción incorrecta. Debe ingresar una de las opciones de arriva.")
print ()
