Cet article explore une technique de visualisation mathématique consistant à générer des motifs complexes à l'intérieur de polygones réguliers en utilisant la proportion dorée.

Description du processus

1. Sélectionner un point initial P0 arbitraire à l'intérieur d'un polygone régulier (par exemple, un pentagone avec sommets P1, P2, ..., P5).
2. À partir de P0, se déplacer vers un sommet aléatoire du polygone et placer un nouveau point P0' à 61.8% de la distance entre P0 et ce sommet (point de division dorée).
3. Colorer ce point P0'.
4. Répéter le processus à partir de P0' pour obtenir de nouveaux points de division dorée.
5. Effectuer cette opération de manière itérative N fois (par exemple, 30 000 fois).

La question posée est : quel motif final est formé par l'ensemble des points de division dorée obtenus ?

2. Approche technique

Étape 1 : Génération des polygones réguliers

Pour créer un polygone régulier à n côtés centré à l'origine :

• Calculer l'angle de rotation : angle = 2 * PI / n
• Calculer les coordonnées de chaque sommet en utilisnat les fonctions tirgonométriques cosinus et sinus
• Stocker ces coordonnées dans une liste de tuples (x, y)

Étape 2 : Calcul des points de division dorée

Pour un point P0 et un sommet PN du polygone :

• Le nouveau point P0' est calculé par : P0' = P0 + (PN - P0) * 0.618

Étape 3 : Visualisation

Utiliser une bibliothèque de graphiques pour afficher :

• Le polygone régulier
• Le point initial
• L'ensemble des points de division dorée générés

3. Implémentation

Étape 1 : Fonction de génération des sommets

# Importation des bibliothèques nécessaires
import math

def generer_sommets_polygone(rayon, nb_sommets):
    """
    Génère les coordonnées des sommets d'un polygone régulier
    
    Paramètres:
        rayon: distance du centre à un sommet
        nb_sommets: nombre de sommets du polygone
    
    Retour:
        Liste des coordonnées (x, y) des sommets
    """
    angle_rotation = 2 * math.pi / nb_sommets
    sommets = []
    
    for i in range(nb_sommets):
        x = rayon * math.cos(i * angle_rotation)
        y = rayon * math.sin(i * angle_rotation)
        sommets.append((x, y))
    
    return sommets

Étape 2 : Calcul et visualisation des points de division dorée

# Importation des bibliothèques de visualisation
import matplotlib.pyplot as plt
import random

def visualiser_division_doree(sommets, iterations=40000, ratio_dor=0.618):
    """
    Génère et visualise les points de division dorée à l'intérieur d'un polygone
    
    Paramètres:
        sommets: liste des sommets du polygone
        iterations: nombre de points à générer
        ratio_dor: ratio de division dorée (par défaut 0.618)
    """
    # Ajout du premier sommet à la fin pour fermer le polygone
    sommets_fermes = sommets + [sommets[0]]
    
    # Extraction des coordonnées X et Y
    coord_x = [point[0] for point in sommets_fermes]
    coord_y = [point[1] for point in sommets_fermes]
    
    # Création de la figure
    plt.figure(figsize=(10, 10))
    
    # Dessin du polygone
    plt.plot(coord_x, coord_y, 'b-', linewidth=2)
    plt.scatter(coord_x, coord_y, color='blue', s=50)
    
    # Point de départ (origine)
    plt.plot(0, 0, 'ro', markersize=8)
    
    # Initialisation des coordonnées du point courant
    x_actuel, y_actuel = 0, 0
    
    # Stockage des points générés
    points_x = []
    points_y = []
    
    # Génération des points de division dorée
    for _ in range(iterations):
        # Sélection aléatoire d'un sommet
        index_sommet = random.randint(0, len(sommets_fermes) - 1)
        x_sommet, y_sommet = sommets_fermes[index_sommet]
        
        # Calcul du nouveau point
        x_actuel = x_actuel + (x_sommet - x_actuel) * ratio_dor
        y_actuel = y_actuel + (y_sommet - y_actuel) * ratio_dor
        
        # Stockage du point
        points_x.append(x_actuel)
        points_y.append(y_actuel)
    
    # Affichage des points générés (on exclut le premier pour une meilleure visualisation)
    plt.scatter(points_x[1:], points_y[1:], color='green', s=1, alpha=0.7)
    
    # Configuration de l'affichage
    plt.axis('equal')
    plt.grid(True, linestyle='--', alpha=0.7)
    plt.title(f'Motif généré par {iterations} divisions dorées')
    plt.show()

4. Applications et tests

Test 1 : Polygones à différents nombres de côtés

Triangle équilatéral (3 côtés)

# Génération d'un triangle
sommets_triangle = generer_sommets_polygone(2, 3)
visualiser_division_doree(sommets_triangle, 1000)

Carré (4 côtés)

# Génération d'un carré
sommets_carre = generer_sommets_polygone(2, 4)
visualiser_division_doree(sommets_carre, 1000)

Pentagone (5 côtés)

# Génération d'un pentagone
sommets_pentagone = generer_sommets_polygone(2, 5)
visualiser_division_doree(sommets_pentagone, 10000)

Hexagone (6 côtés)

# Génération d'un hexagone
sommets_hexagone = generer_sommets_polygone(2, 6)
visualiser_division_doree(sommets_hexagone, 10000)

Test 2 : Variation du ratio de division

# Génération d'un hexagone avec un ratio différent
sommets_hexagone = generer_sommets_polygone(2, 6)
visualiser_division_doree(sommets_hexagone, 10000, 0.7)

5. Observations

La visualisation révèle que, quel que soit le polygone régulier de départ, l'application itérative de la division dorée génère des motifs fracatls distinctifs. La modification du ratio de division ou du nombre de côtés du polygone initial change la densité et la forme du motif final.