Créer une figure fractale avec python part1 (joint de Shelpinsky)

1. Qu'est-ce qu'une figure fractale?

Une figure fractale est la même que la figure originale, quel que soit son agrandissement. Le joint Shelpinsky, qui est une figure fractale typique, est illustré ci-dessous.

2. Création d'un joint de ski shellpin

fractal.py

import matplotlib.pyplot as plt
import matplotlib.patches as pat
import math

#triangle = [(x1,y1),(x2,y2),(x3,y3)]

#Sortez les coordonnées du triangle dans le triangle d'entrée
def return_triangle(triangle):
    x1 = (triangle[0][0] + triangle[1][0])/2
    y1 = (triangle[0][1] + triangle[1][1])/2
    x2 = (triangle[1][0] + triangle[2][0])/2
    y2 = (triangle[1][1] + triangle[2][1])/2
    x3 = (triangle[2][0] + triangle[0][0])/2
    y3 = (triangle[2][1] + triangle[0][1])/2
    new_triangle = [(x1,y1),(x2,y2),(x3,y3)]
    return new_triangle

#Sortie de la distance entre deux points
def distance(p1,p2):
    return math.sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2)

#Produit un triangle constitué des deux points les plus proches du point p aux points p et triangle
def select_neighbor_points(p, triangle):
    distance1 = distance(p, triangle[0])
    distance2 = distance(p, triangle[1])
    distance3 = distance(p, triangle[2])
    if distance1 > distance2:
        if distance1 > distance3:
            return [p, triangle[1], triangle[2]]
        else:
            return [p, triangle[0], triangle[1]]
    else:
        if distance2 > distance3:
            return(p, triangle[0],triangle[2])
        else:
            return(p, triangle[0],triangle[1])
            
#Générez une figure fractale. Plus le nombre d'itérations est élevé, plus il est compliqué
def produce_fractal1(triangle, iteration):
    if iteration == 0: return 0
    p1 = triangle[0]
    p2 = triangle[1]
    p3 = triangle[2]
    new_triangle = return_triangle(triangle)
    p = pat.Polygon(xy = new_triangle,fc = "white", ec = "black")
    ax.add_patch(p)
    produce_fractal1(select_neighbor_points(p1,new_triangle), iteration-1)
    produce_fractal1(select_neighbor_points(p2,new_triangle), iteration-1)
    produce_fractal1(select_neighbor_points(p3,new_triangle), iteration-1)

triangle = [(0.2, 0.2), (0.8, 0.2), (0.5, 0.8)]　#Coordonnées du triangle initial
fig = plt.figure(figsize=(5, 5))
ax = fig.add_subplot(1,1,1)
p = pat.Polygon(xy = triangle,fc = "white", ec = "black")
ax.add_patch(p)
produce_fractal1(triangle,6)
fig.savefig("./fractal.png ") #Enregistrer l'image

Facile à mettre en œuvre avec un traitement récursif L'exécution a été effectuée avec jupyter.

fractal.py

produce_fractal1(triangle,iteration)

L'augmentation du nombre d'itérations crée des triangles plus profonds.

3. Résumé

En implémentant correctement le processus récursif, j'ai pu créer une casquette Shelpinsky.En changeant le contenu du processus récursif, j'ai pu créer d'autres figures fractales.