Jardins : Forêt enneigée

Ce script génère une image aléatoire de forêt enneigée en utilisant deux fractales très connues : l’Arbre de Pythagore et le Flocon de Koch.

Les fractales

Le Flocon de Koch

Le Flocon de Koch utilise une courbe fractale. Une courbe fractale est un dessin composé de segment dont la forme de base va être reproduite à l’infini.

Dans le cas de la courbe de Koch, sur chaque segment, un triangle va être dessiné, et pour chaque niveau, on va rajouter un triangle sur les nouveaux segments.

Pour créer cette courbe, on va utilisé le principe de récursivité, c’est à dire qu’on va appeler dans une fonction python la fonction elle-même.

def cote(longueur,niveau):
    if niveau==0:
        forward(longueur)
    else:
        cote(longueur/3,niveau-1)
        left(60)
        cote(longueur/3,niveau-1)
        right(120)
        cote(longueur/3,niveau-1)
        left(60)
        cote(longueur/3,niveau-1)

On exécute la fonction cotée en définissant la longueur et le niveau de répétition souhaité. Ligne 2, on vérifie que le niveau est égal à 0. S’il ne l’est pas, ligne 5, on rappelle la fonction et cette fois-ci la longueur est divisée par 3 et on enlève 1 au niveau. Ainsi, on répète tant que le niveau n’est pas égal à 0, et quand le niveau est égale à 0, on avance de « longueur ».

En répétant cela plusieurs fois, on obtient la courbe de Koch.

Pour obtenir un flocon, on répète cette courbe trois fois.

def flocon(longueur,niveau,x,y):
    width(1)
    penup()
    goto(x,y)
    pendown()
    for i in range(3):
        cote(longueur,niveau)
        right(120)

Ce code provient de https://www.numworks.com/fr/professeurs/activites-pedagogiques/premiere/flocon/

L’arbre de Pythagore

L’arbre de Pythagore fonctionne de la même manière : la fonction s’appelle elle-même.

def arbre(n,longueur,w,r1,g1,b1,r2,g2,b2):
  if n==0 :
    pencolor(r1,g1,b1)
    forward(longueur)
    backward(longueur)
    pencolor(r2,g2,b2)
  else:
    width(w) 
    forward(longueur/3)
    left(50) 
    arbre(n-1,longueur*2/3,w/1.2,r1,g1,b1,r2,g2,b2)
    right(2*50)
    arbre(n-1,longueur*2/3,w/1.2,r1,g1,b1,r2,g2,b2)
    left(50)
    backward(longueur/3)

Cette fonction prend plusieurs paramètres :

• le niveau n de répétition
• la longueur du tronc
• la largeur w : afin que les arbres éloignés soient plus fins que les arbres au premier plan, on définit la largeur. Plutôt que d’utiliser w-1 (sinon après un certain niveau de répétition la valeur deviendrait négative), on utilise w/1.2 ce qui permet de réduire la valeur sans changer son signe.
• r1,g1,b1 : qui définissent en RGB la couleur des feuilles.
• r2,g2,b2 : qui définissent en RGB la couleur du tronc.

Ce code provient de https://my.numworks.com/python/cent20/arbre

Le fond

L’exécution du fond et des montagnes

A chaque exécution le fond va être d’une couleur aléatoire.

color(randint(10,250),255,255)
begin_fill()
goto(-640,700)
pendown()
goto(640,700)
goto(640,-700)
goto(-640,-700)
end_fill()

A chaque fois que nous exécutons le script, le résultat est unique, les montagnes ayant une forme définie auront une couleur aléatoire.

Script d’une des montagnes :

for i in range (10):
    for i in range (5):
        forward(20)
        right(2)
    for i in range (5):
        forward(10)
        left(2)

Cette boucle crée des fragments de cercles collés, qui forment une ondulation.

Les trois montagnes donnent cette image, avec des couleurs uniques à chaque fois.

L’exécution des arbres

On dessine 7 arbres en tout : 2 sur la montagne du fond, 2 sur la montagne du milieu et trois sur la montagne du devant. Chaque arbre a un secteur donné sur sa montagne et il est dessiné dans ce secteur, de façon unique à chaque fois.

Les arbres sur la montagne la plus éloignée sont plus petits, plus fins et plus sombres, cependant chaque arbre est d’une couleur, d’une taille et d’une largeur différentes à chaque exécution.

Voici par exemple l’exécution d’un arbre sur la montagne du fond

penup()
goto(randint(-550,-450),randint(120,160))
pendown()
setheading(90)
color(75,randint(40,50),randint(0,20))
arbre(9,randint(50,90),randint(4,7),randint(130,180),randint(160,180),180,75,randint(40,50),randint(0,20))

L’exécution des flocons

Ensuite on exécute les flocons:

for i in range (randint(30,45)):
    setheading(randint(0,360))
    color(randint(0, 220),randint(110, 240),255)
    begin_fill()
    flocon(randint(20,50),randint(3,5),randint(-639,639),randint(-310,310))
    end_fill()

A chaque exécution, le nombre de flocons est différent. Chaque flocon est orienté différemment , à une couleur, une taille, un niveau de répétition, et un emplacement différent.

L’image finale

Télécharger le .py

Si vous voulez l’essayer, vous trouverez le script ci-dessous, cependant faites attention, chaque arbre prend relativement longtemps à s’exécuter, ajouté aux flocons, le script prend environ 1h30 à s’exécuter.

1ère spé NSI 2022 - 2023