Depuis la nuit des temps, l’Homme est fasciné par ce qu’il se trouve au-dessus de sa tête à tel point qu’il a créé des cartes pour répertorier ces astres lumineux. Cette fascination pour l’inconnu a perduré au fil des siècles et, grâce aux cartes du ciel, les aventuriers d’hier, d’aujourd’hui et de demain on réussit à se repérer dans l’espace et surtout à rêver comme nous le montre James Michener dans La course aux étoiles.
-Prisonnier ? -Oui. Les étoiles peu à peu vous happent. Elles vous font changer de perspective, d’une façon radical Il lui tendit la carte avec respect et lui demanda : « Avez-vous jamais vus les étoiles ? »
La course aux étoiles, p. 76
Genèse de l’idée
Lors de l’explication du projet, nous avons réfléchi et nous avons tout de suite pensé au domaine de l’astronomie. Au début nous avons pensé que faire une représentation en Pixel Art serait une bonne idée mais après de longues réflexions nous sommes revenus aux bases de l’astronomie et nous avons eu notre idée actuelle ; une carte du ciel de l’hémisphère Nord. C’est ainsi que notre projet a pu débuter…
Développement
Pour commencer nous avions besoin d’un fond dégradé du bleu au noir pour représenter notre beau ciel étoilé. De ce fait nous avons dû chercher comment le réaliser et nous avons trouvé un exemple de code sur Internet et nous avons pu l’adapter à notre manière.
Fond dégradé issu de notre script
Une fois le fond terminé et opérationnel, nous nous sommes concentrés sur la création des étoiles qui composeront notre carte. Ainsi, nous avons défini 3 types d’étoiles :
Les petites étoiles :
def etoilep():
pensize(1)
pencolor("white")
for i in range(150):
penup()
x,y = randint(-640,640), randint(-360,360)
goto(x,y)
pendown()
circle(1)
Nous avons positionné les petites étoiles de façon aléatoire grâce à un module python nommé random permettant un meilleur rendu visuel puisqu’elles servent à définir les étoiles les plus lointaines et donc visibles seulement par la NASA, l’ESA et également visibles dans les films de science-fiction tel H2G2.
Les étoiles moyennes :
def etoilen():
pendown()
pensize(2)
pencolor("yellow")
for i in range(5):
right(30)
forward(2)
right(120)
forward(2)
left(78)
Celles-ci servent à constituer les étoiles formant les constellations visibles dans notre hémisphère et donc forment les différentes constellations.
L’étoile polaire :
def etoilepolaire():
pendown()
pensize(2)
pencolor("yellow")
for i in range(5):
right(30)
forward(2)
right(120)
forward(2)
left(78)
L’étoile polaire est une étoile particulière. En effet, sa position dans l’espace ne varie pas et indique globalement le nord. Elle servait notamment aux marins pour se repérer en pleine mer. C’est pour ça que nous l’avons défini aux coordonnées (0 , 0).
Rendu final du script après exécution
Maintenant que nous avons toutes nos étoiles, il faut les positionner !
Donc, pour ce faire, nous avons utilisé une carte du ciel en notre possession et nous avons mesuré à la règle la distance des étoiles par rapport à l’étoile polaire en essayant de les mettre à une certaine échelle pour ne pas sortir du cadre imposé.
Une fois toutes les mesures prises, nous avons créé deux listes, une première avec toutes les coordonnées x (horizontales) et une deuxième avec tous les coordonnés y (verticales) des étoiles formant les constellations. Pour séparer les constellations entre elles nous avons utilisé le mot-clé « None » .
Cependant, celui-ci nous a posé quelques problèmes. En effet, nous avions tout d’abord mis les « None » entre parenthèses (ne nous demandez pas pourquoi on a fait ça, on ne le sait pas nous-mêmes), ce qui nous a posé des problèmes. Après s’être rendu compte de cette erreur, un autre problème est apparu ! Mais nous avons pu la parer puisqu’il suffisait de mettre une condition à ce « None » . S’il apparait on passe au nombre suivant de la liste et s’il n’y est pas on trace !
En parlant de problèmes, nous en avons eu un autre, l’échelle des constellations. En effet, nous nous y sommes pris à trois fois pour avoir la bonne taille, d’abord trop petite, ensuite trop grande, mais à coups mathématiques très compliqués, nous avons réussi à trouver la bonne échelle !
Conclusion
Malgré les quelques difficultés rencontrées nous avons réussi à modéliser, assez grossièrement, nous devons l’admettre, une carte du ciel. Néanmoins, cette esquisse ravira sans aucun doute les amateurs d’astronomie pour sa beauté graphique et les informations données, malgré son imprécision elle reste tout de même assez juste et véridique. Notre projet se prête bien au thème de l’astronomie et nous en sommes fières. Cependant , il peut bien évidemment être amélioré avec un script plus optimisé et un peu plus de constellations.
Et puis, comme disait Léonard de Vinci, Celui qui s’oriente sur l’étoile ne se retourne pas.
« L’amas de trous noirs » est le nom de notre premier projet développé en Python. Notre petit programme vous permettra de profiter d’un magnifique ciel étoilé… avec quelques trous noirs. En effet, ce programme générera pour vous une image d’une beauté à couper le souffle… Enfin, nous espérons !
Introduction
Représenter ce que l’être humain ne peut atteindre est une de ses passions favorites. En effet, nous allons vous présenter notre projet Python se prénommant : L’amas de trous noirs. Effrayant, n’est-ce pas ?
Le résultat final doit ressembler à ceci, mais vous le savez déjà :
Cette image est un des multiples résultats de notre code. Nous y reviendrons plus tard.
Comme vous pouvez le voir, il y a plusieurs éléments sur cette image : des trous noirs, des étoiles et un arrière-plan noir. Commençons par le programme pour former les trous noirs.
Nous avons utilisé le module turtle de python qui permet de dessiner à l’écran. Dans la suite de l’article, nous ferons référence à ce module sous le nom de tortue.
Les trous noirs
Un code non optimisé
C’est la première chose sur laquelle nous avons travaillé. Afin que vous conserviez votre santé mental, nous éviterons de vous montrer le code qui forme cette image :
Si vous le voulez vraiment :
def cercle(rayon, x, y, r=1, v=1, b=1):
pensize(5)
while rayon > 372 and r < 254:
penup()
goto(x, y - rayon)
pendown()
pencolor((r, v, b))
circle(rayon)
rayon -= 1
r += 2
while rayon > 244 and v < 254:
penup()
goto(x, y - rayon)
pendown()
pencolor((r, v, b))
circle(rayon)
rayon -= 1
v += 2
while rayon > 119 and b < 254:
penup()
goto(x, y - rayon)
pendown()
pencolor((r, v, b))
circle(rayon)
rayon -= 1
b += 2
while r > 0 and v > 0 and b > 0:
penup()
goto(x, y - rayon)
pendown()
pensize(2)
pencolor((r, v, b))
circle(rayon)
rayon -= 1
b -= 16
v -= 16
r -= 16
cercle(500, 0, 0)
Ce code ne nous satisfait pas car il a des limites d’utilisations. C’est-à-dire qu’il est impossible de dessiner des trous noirs de n’importe quel diamètre. On a par exemple ce cas où l’on choisi un rayon de 200 :
Ici, on constate que le dégradé n’est pas celui que l’on souhaitait.
Maintenant que nous avons vu un code qui vous pique encore les yeux, nous allons voir une autre version plus optimisée et bien plus flexible.
Un code optimisé
Avant toute chose, nous définissons au début de notre programme colormode(255) qui nous permettra de définir des couleurs au format (r, v, b), r pour rouge, v pour vert et b pour bleu qui sont les trois teintes permettant de composer n’importe quelle couleur.
Ensuite nous définissons notre fonction trou_noir(). Nous allons la découper en plusieurs portions de code afin de vous l’expliquer étape par étape.
Première étape : Initialisation de diverses informations.
colormode(255)
def trou_noir(x, y, rayon):
color(0, 0, 0)
pensize(5)
r = -1
v = -1
b = -1
penup()
goto(x, y - rayon - 20)
pendown()
Notre fonction aura donc besoin de trois paramètres : les coordonnées x, y et le rayon du trou noir. Nous indiquons que la couleur du stylo sera noir, en raison de l’arrière-plan qui sera noir également. Nous définissons le taille du trait à 5, qui est la valeur la plus basse tout en évitant des artéfacts au niveau du trou noir comme ceci :
Nous définissons trois variables qui, comme leur nom l’indique, seront les variables liées au changement de couleur. Nous les définissons avec une valeur négative, ce qui peut paraitre assez étrange, car les valeurs minimales pour le vert, le rouge ou le bleu sont zéro. Nous vous expliquerons un peu plus bas pourquoi nous faisons cela.
La fonction penup() permet de lever le stylo, la fonction goto() permet de le déplacer. On met en paramètre les coordonnées x et y en paramètre. La fonction pendown() permet elle, de poser le stylo.
Concernant la fonction goto(), elle prend en paramètre les coordonnées x et y, qui représente un point de l’écran. La tortue n’est capable de dessiner un cercle qu’à partir de sa base (le point le plus bas du cercle). Nous souhaitons utiliser le centre géométrique d’un cercle pour les positionner. Nous allons donc décaler la coordonnée y de la distance du rayon. Cela donne le code suivant : goto(x, y - rayon).
Nous avons choisi d’ajouter autour de notre trou noir une zone noire (🥴) de 20 pixels d’épaisseur (cette valeur a été défini de façon arbitraire). Nous verrons par la suite que c’est un choix esthétique, cette marge de 20 pixels se retrouve donc dans l’appel de notre fonction goto() : goto(x, y - rayon - 20).
Ce disque a été rajouté afin d’améliorer la fonction trou_noir() : en effet, après une première version de la fonction trou noir, nous avons amélioré le rendu graphique en dessinant un premier disque noir sur lequel la tortue dessine le trou noir. Cela apporte deux avantages : produire la marge de 20 pixels autour du trou noir (cf. paragraphe au-dessus) et remplir le centre de notre trou noir. Voyez ainsi :
Ce disque noir sert de transition entre le ciel étoilé (que vous verrons par la suite) et le trou noir en lui-même.
Troisième étape : Construction du trou noir (dégradé du rouge vers le blanc).
while r < 255:
penup()
goto(x, y - rayon)
pendown()
r += 2
pencolor((r, 0, 0))
circle(rayon)
rayon -= rayon/500
while v < 255:
penup()
goto(x, y - rayon)
pendown()
v += 2
pencolor((r, v, 0))
circle(rayon)
rayon -= rayon/500
while b < 255:
penup()
goto(x, y - rayon)
pendown()
b += 2
pencolor((r, v, b))
circle(rayon)
rayon -= rayon/500
Ces trois boucles while sont très similaires. Elles servent à créer le dégradé du trou noir. Ce que notre tortue fait est de dessiner un cercle d’une couleur différente à chaque fois que la boucle se répète. La boucle se termine une fois que la variable de la couleur donnée dans la condition while a atteint son maximum, soit 255. A chaque itération, nous incrémentons de 2 chaque variable de couleur, et nous le faisons juste avant de dessiner le cercle. Avec cette incrémentation, il nous faudrait 128 itérations pour arriver à la valeur 256. Cette valeur est donc supérieur à 255, nous avons donc décidé d’initialiser chaque variable de couleur à -1 afin de compenser ce problème. Pour la variable r par exemple, la première fois que notre boucle va s’exécuter, elle va s’incrémenter de 2 ( -1 + 2 = 1 ), puis choisir une couleur pour le stylo : pencolor((r, 0, 0)), puis dessiner le cercle. Lors de la dernière itération, r est égal à 253, donc 253 + 2 = 255, la tortue dessine le cercle avec cette valeur. Nous sortirons ensuite de la boucle. Nous faisons ceci trois fois, pour les trois variables de couleurs.
La dernière ligne qui est intéressant dans l’extrait cité est rayon -= rayon/500. La valeur 500 provient de notre « programme d’essai », celui non optimisé. Nous avons utilisé la proportionnalité par rapport à la valeur trouvée grâce à ce programme. Dans le programme d’essai nous retirions 1 au rayon pour un cercle de rayon 500. Ici nous retirons au rayon le résultat de la division du rayon par 500. Par exemple si le rayon est 500, on retirera 1 ( 500/500 = 1 ), si c’est 250, on retirera 0,5 ( 250/500 = 0,5 ), si c’est 750, on retirera 1,5 ( 750/500 = 1,5 ), etc. Ceci permet de faire des trous noir de la taille que l’on souhaite.
Quatrième étape : Dégradé du blanc au noir de finition.
while r > 0 and v > 0 and b > 0:
penup()
goto(x, y - rayon)
pendown()
pencolor((r, v, b))
circle(rayon)
rayon -= rayon / 500
b -= 16
v -= 16
r -= 16
pencolor("black")
circle(rayon)
Cette dernière boucle permet de faire un fort dégradé entre le blanc et le centre du trou noir, qui est… noir (🥴). Elle n’a rien de particulier par rapport à ce que l’on a expliqué plus haut mis à part la valeur forte de la réduction des valeurs des trois variables de couleurs (que l’on décrémente de 16) et également la condition de la boucle qui permet qu’elle s’arrête une fois que la couleur atteinte est le noir.
Les deux dernières lignes de l’extrait permettent d’éviter ce problème :
Les étoiles
Voici le code pour former les étoiles :
def etoile(x, y, branche, longueur, couleur=(255, 230, 0)):
penup()
goto(x, y)
degre_angle = 180 - (360 / (branche * 2))
begin_fill()
fillcolor(couleur)
for i in range(branche):
forward(longueur)
right(degre_angle)
end_fill()
Cette fonction prend en paramètre les coordonnées x et y, le nombre de branche, la longueur des branches (plus précisément la longueur des segments constituants l’étoile) et la couleur (avec une couleur par défaut qui est un jaune-orange qui tend plus vers le jaune). On lève notre stylo, on se positionne de manière à ce que le centre de l’étoile soit les coordonnées données en paramètres et… pas de pendown() ? En effet celui-ci serait inutile pour former les étoiles car nous n’allons pas utiliser la fonction de tracé de ligne mais plutôt utiliser la fonction de remplissage (de couleur) de zone. Ensuite, nous créons une variable degre_angle. Elle est très importante car elle va définir le degré des angles qui vont permettre de former l’étoile. Regardez :
L’étoile est formée de la même manière que l’extrait cité sauf qu’ici le stylo est baissé, et il n’y a pas de couleur de remplissage. Les angles qui nous intéressent sont au bout des branches. Ce sont ces angles là que le programme contrôle.
En A), notre tortue avance. Elle est à une position avec un angle de 0°. L’angle en rouge est égal à 180°. C’est notre 180 dans la formule ! Et (360 / (branche * 2)) est en fait l’angle intérieur. Pour savoir la valeur de cet angle, il faut imaginer l’étoile dans un cercle. La somme de tous les sommets de cette étoile dans un cercle donne 360°. Et dans une étoile, le nombre de sommet est le double du nombre de branche.
Ensuite en B), elle s’oriente de l’angle calculé dans la variable degre_angle. Le trait violet est un trait de construction rajouté pour que le schéma soit plus clair.
Pour finir en C), la tortue avance. Ici on voit bien l’angle formé qui est celui de degre_angle. Le trait en cyan est un trait de construction.
D’une pierre deux coup, nous vous avons expliqué aussi la boucle qui est dans le programme. Avec begin_fill(), fillcolor(couleur) et end_fill() nous remplissons l’intérieur de l’étoile avec la couleur donnée en paramètre.
Le ciel (arrière-plan et étoiles)
Cool ! On a bien avancé. On continue avec cette fois-ci un bon bgcolor("black") qui est censé faire un arrière-plan en noir et… non. Cela ne va pas marcher, nous verrons cela un peu après, une fois le code entièrement présenté. Nous allons donc concevoir une fonction arriere_plan() :
def arriere_plan():
# .ps est incapable de récupérer le bgcolor() selon internet...
# Et des barres blanches apparaissent avec ce code dans le .png généré...
penup()
goto(-640, 0)
pendown()
pensize(900)
forward(1280)
Il y a un bavard dans le code de ce que je vois, mais il a raison (ou on a tous les deux torts, c’est une éventualité). Encore une fois, nous verrons ceci un peu plus tard. Cette fonction est très simple, elle conçoit simplement un fond noir, en se positionnant le plus à gauche du canvas (zone de dessin) et en traçant un trait de la taille du canvas (le résultat doit avoir une taille de 1280 pixels de largeur par 720 pixels d’hauteur) avec une taille exagérée.
def ciel():
arriere_plan()
liste_couleur = [(255, 255, 255), (255, 230, 0)]
for i in range(0, randint(71, 121)):
liste_couleur[1] = (255, randint(150, 230), 0)
etoile(randint(-630, 630), randint(-350, 350), 5, 10, choice(liste_couleur))
for i in range(0, randint(16, 31)):
liste_couleur[1] = (255, randint(150, 230), 0)
etoile(randint(-620, 620), randint(-340, 340), 7, 20, choice(liste_couleur))
for i in range(0, randint(6, 16)):
liste_couleur[1] = (255, randint(150, 230), 0)
etoile(randint(-600, 600), randint(-320, 320), 15, 40, choice(liste_couleur))
Occupons nous maintenant de la fonction ciel(). Nous appelons la fonction arriere_plan() puis le programme dessine des étoiles dans notre ciel. Nous utilisons simplement trois boucles qui dessineront 3 types d’étoiles différentes. En effet grâce aux paramètres branche et longueur, nous pouvons former des étoiles complètements différentes, diversifiant le ciel. Concernant le paramètre couleur, nous avons une liste qui varie à chaque fois que la boucle se répète. C’est plus précisément le second élément qui varie. On modifie aléatoirement la quantité de vert dans la couleur, rendant l’étoile plus ou moins orangée. La fonction choice() permet de choisir un élément aléatoirement parmi une liste donnée en paramètre. Pour finir sur ce bout de code, chaque boucle for génère un nombre aléatoire d’étoile entre deux valeurs précisées (ex : randint(71, 121)). On remarque que les étoiles plus petites apparaissent plus nombreuses.
Voici un rendu de la fonction ciel() :
Taille du canvas : 2560×1080 pixelsTaille du canvas : 1280×720 pixels
On remarque bien le fond généré « artificiellement » dans la première image, et comment cela rend dans les bonnes dimensions.
Assemblement et problèmes
Bien, nous avons notre ciel, plus qu’à rajouter les trous noirs. Nous en ferons trois :
On appelle donc notre fonction ciel() et nous générons trois trous noirs. Ils sont positionnés aléatoirement mais pour éviter une fusion de trou noir, nous les plaçons dans des coordonnées où ils ne peuvent s’entrechoquer. On remarque qu’il y a un décalage de 150 entre chaque plage de coordonnées x. C’est dû à la taille qui est aléatoire entre 50 et 150.
Une fusion de trou noir… C’est très beau, vous ne trouvez pas ?
Nous vous avions proposé un résultat en début d’article, en voici un autre :
Le rendu turtle Le fichier PNG généré
On remarque diverse imperfection. La plupart provienne d’un problème lors de la conception du fichier postscript et nous n’avons pas trouver comment régler ce problème.
Un autre problème que nous avons eu a été celui-là :
Effectivement, je n’ai plus l’impression de voir un ciel…
Bon, qu’est-ce qui s’est passé ? Lorsque nous avons généré cette image, nous utilisions la fonction bgcolor("black") pour générer le fond noir sauf qu’après une petite recherche sur internet, le fichier postscript ne prend pas en compte cette action, il ne la « voit » pas. Nous avons donc dû changer par la fonction arriere_plan() que nous vous avons expliqué plus haut.
Conclusion
Vous pouvez former des images complètement différentes de ce que l’on a généré simplement en modifiant quelques valeurs ou en rajoutant une boucle for… Vous pouvez faire un ciel beaucoup plus dense, des dégradés plus profonds, des trous noirs plus grands, etc. Nous avons voulu faire un programme qui puisse avec très peu de modification générer des résultats d’une grande diversité.
Télécharger le .py
Si l’envie vous prend de rendre ces personnalisations plus simples d’accès et/ou optimiser notre code, voici un petit cadeau :
Le premier projet de la classe de 1ère NSI est « Regard de géomètre ». Ce projet consiste en la création d’une image basée sur un ou plusieurs thèmes donnés. Pour notre image, on a choisi les thèmes astronomie et balles et ballons. Nous avons voulu représenter le système solaire mais en remplaçant les planètes et le Soleil par des balles et des ballons de différents sports.
Les étapes de création de notre image
Après avoir choisi nos thèmes et décidé de l’illustration que l’on souhaitait faire, nous avons commencé par le fond de notre illustration. Pour cela, on voulait un fond noir avec des étoiles représentées par des points blancs et de tailles différentes placées aléatoirement sur l’image. Cependant, les grosses étoiles à cause de leur couleur blanche, se voyaient trop par rapport aux plus petites. On a alors ajouté une couleur un peu plus grise pour les grosses étoiles mais on a gardé le blanc pour les petites. Pour faire cela, nous avons utilisé une instruction conditionnelle :
import turtle
import random
turtle.speed(0)
for i in range(150):
turtle.penup()
turtle.goto(random.randint(-640,640),random.randint(-350,350))
turtle.pencolor("black")
turtle.pendown()
a=random.randint(1,5)
if a<2:
turtle.begin_fill()
turtle.fillcolor("white")
turtle.circle(a)
turtle.end_fill()
else:
turtle.begin_fill()
turtle.fillcolor("#e1e1df")
turtle.circle(a)
turtle.end_fill()
Ce qui donne avec le fond:
Tracé du ciel étoilé
Dans un second temps, nous avons choisi les balles que l’on voulait représenter puis nous les avons tracées chacune séparément pour avoir le rendu le plus fidèle possible. Les balles choisies sont:
la balle de tennis
le ballon de basket-ball
le ballon de rugby
la balle de base-ball
A l’origine, on voulait faire le ballon de football plutôt que la balle de base-ball mais le motif de ce ballon est un peu trop complexe à faire et n’apportait que peu d’intérêt pour notre script.
Dans la dernière étape de la création de notre image, nous avons regroupé toutes nos créations (fond, balles et ballons) dans un même script et nous avons rajouté certaines fonctionnalités comme les ellipses ou l’effet d’ombre qui vous seront montrés plus loin. Mais, lors de ce regroupement, nous avons fait face à plusieurs problèmes notamment au positionnement des balles et également à leur proportion (un ballon de basket ne peut pas être plus petit qu’une balle de tennis). Pour cela, on a effectué une suite d’essai-erreur jusqu’à ce que le résultat nous plaise.
Rendu final
Les fonctions utilisées dans le script
La première fonction importante de ce script est la fonction « orbite ». Elle consiste en la création d’une « fausse ellipse » à l’aide de 4 arcs de cercles de rayons différents. Cette fonction est plutôt simple mais extrêmement efficace.
def orbite(rayon):
turtle.seth(-45)
for i in range(2):
turtle.circle(rayon,90)
turtle.circle(rayon/2,90)
return()
La deuxième fonction marquante de ce script est la fonction permettant de créer un effet d’ombre sur les balles et ballons ayant une forme circulaire. Pour cela, il faut créer un dégradé de couleur formé à l’aide de cercles de plus en plus petits dont la couleur varie en même temps que le rayon diminue. Cette fonction s’appelle « surface ».
def surface(couleur,rayon,posx,posy):
r=couleur[0]
g=couleur[1]
b=couleur[2]
turtle.pensize(5)
for i in range(51):
turtle.home()
turtle.goto(posx,posy)
turtle.pendown()
if ((r-i*1.5)>=0) and ((g-i*1.5)>=0) and ((b-i*1.5)>=0):
r1=r-i*1.5; g1=g-i*1.5; b1=b-i*1.5;
elif ((r-i*1.5)<0): r1=r
elif ((g-i*1.5)<0): g1=g
else: b1=b
turtle.pencolor((r1/255,g1/255,b1/255))
turtle.circle((100-2*i)*rayon)
turtle.penup()
Enfin, la dernière fonction est la fonction étoile, elle permet comme son nom l’indique de tracer des étoiles de taille et avec un nombre de branches variables. Elle a pour paramètres le nombre de branches et la longueur des branches.
def etoiles(branches, longueur):
turtle.begin_fill()
turtle.fillcolor("white")
for i in range(branches):
turtle.forward(longueur)
turtle.right(180+180/branches)
turtle.forward(longueur)
turtle.left(180-180/branches)
turtle.end_fill()
Malheureusement, cette fonction a un défaut que l’on n’a pas su régler. Lorsque l’on choisit un nombre pair de branches, le nombre n’est pas respecté.
Exemple: lorsque l’on exécute etoiles(6,100). Le nombre de branches n’est pas correct.
Alors que lorsqu’on veut faire une étoile avec un nombre de branches impair, le nombre de branches est respecté.
Exemple: lorsque l’on exécute etoiles(9,100). Le nombre de branches est correct.
Problèmes rencontrés
Lors de la création de notre script, nous avons rencontré plusieurs problèmes comme le positionnement des balles ou encore la proportion des ballons mais également des problèmes qui survenaient lorsqu’on voulait créer une image. Ce problème venait de la commande bgcolor(). Cette fonction consiste à colorier le fond de la toile par la couleur de son choix. Cependant, sur le script nous permettant de créer nos images, le fond n’apparaissait pas. Pour résoudre ce problème, nous avons rajouté au script une boucle faisant des allers-retours sur la toile à l’aide d’un stylo épais permettant de créer manuellement ce fond.
turtle.goto(-760,400)
turtle.pensize(10)
turtle.right(90)
for i in range(75):
turtle.forward(420*2)
turtle.left(90)
turtle.forward(10)
turtle.left(90)
turtle.forward(420*2)
turtle.right(90)
turtle.forward(10)
turtle.right(90)
Conclusion sur notre premier projet en NSI
Ce premier projet nous a permis d’approfondir nos connaissances en turtle et de créer notre premier « gros script » de cette année en python en faisant appel à toutes les fonctions vues en cours. Nous aurions pu essayer d’apporter des améliorations avec un peu plus de temps en ajoutant par exemple d’autres balles plus complexes comme la balle de golf.
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.
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)
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.
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
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.
Une horloge analogique… Qu’est-ce cela peut bien être… Eh bien, c’est tout simplement une horloge avec des aiguilles ! Ainsi, ce programme vous permettra, grâce à Turtle, d’afficher une horloge analogique…
Introduction
La spécificité de cette horloge, est que celle-ci est dynamique. C’est-à-dire que les aiguilles bougent en fonction de l’heure réel. Sinon cela serait trop facile, il suffirait seulement de dessiner un cercle pour le cadran, et des segments pour les aiguilles, et c’est fini. Heureusement, ce n’est pas le cas.
Quelques fonctions
Pour afficher l’heure réel, il faut d’abord récupérer l’heure réel… Pour cela, j’utilise la fonction time.strftime(), à partir du module time, je récupère une donnée de la date actuelle, en l’occurrence j’ai besoin de 3 données : l’heure, la minute, et la seconde. Voici donc une fonction que j’ai codé qui m’a permis de récupérer une de ces 3 données :
def get_time(u):
match u:
case "h":
return int(strftime("%I"))
case "m":
return int(strftime("%M"))
case "s":
return int(strftime("%S"))
Ici, j’ai utilisé la déclaration match, qui permet, entre autres, de comparer la valeur d’une variable, ici la variable u (pour unité). Par exemple, en appelant la fonction suivante get_time("h"), elle me renvoi la valeur de l’heure actuelle, à l’heure où j’écris cet article, il est exactement 01:44 donc en appelant la fonction maintenant, elle me renverrait la valeur 1. À savoir qu’utiliser la déclaration match n’est absolument pas obligatoire, j’aurais très bien pu utiliser une structure conditionnelle traditionnelle avec les déclarations if, elif, et else.
Désormais, j’ai besoin d’afficher le cadran de l’horloge, pour cela, rien de plus simple :
def draw_clock(x, y, rayon):
travel(x, y-rayon)
pencolor((0,)*3)
fillcolor((255,)*3)
begin_fill()
circle(rayon)
end_fill()
travel(x, y-rayon+10)
fillcolor(7, 24, 31)
begin_fill()
circle(rayon-10)
end_fill()
travel(x, y-5)
fillcolor(85, 91, 92)
begin_fill()
circle(5)
end_fill()
penup()
goto(x, y)
setheading(90)
pencolor((255,)*3)
for i in range(60):
forward(rayon-(25 if i%5 == 0 else 15))
pendown()
forward(25 if i%5 == 0 else 15)
penup()
goto(x, y)
right(6)
C’est une fonction plutôt simple, bien qu’elle soit assez lourde. On dessine des cercles, et on fait les marquages des minutes et des heures. J’ai dans cette fonction, utilisé une autre fonction qui ne vient pas des modules importés, la fonction travel() (pour voyager). J’aime beaucoup cette fonction car elle est extrêmement simple, et permet d’économiser quelques lignes :
def travel(x, y):
penup()
goto(x, y)
pendown()
En fait, c’est tout simplement l’équivalent d’un goto(), mais sans laisser les traces du pinceau ! Voici donc le cadran, il est fixe :
J’ai également voulu ajouter dans le fond un mur en briques. Pour ne pas laisser le fond vide, la fonction fait seulement 7 lignes :
def wall_brick(x, y, width_bricks, height_bricks):
for i in range(height_bricks):
for j in range(width_bricks):
if i % 2 == 0:
fill_rect(x+65*j, y+35*i, 60, 30, (161, 84, 68))
else:
fill_rect(x+30+65*j, y+35*i, 60, 30, (161, 84, 68))
Les paramètres sont simples, la position du mur (le bas à gauche du mur) via x et y, et le nombre de briques en longueurs, ainsi que le nombre de briques en hauteur. fill_rect() est une fonction maison inspiré de kandinsky.fill_rect(), elle permet de dessiner des rectangles :
def fill_rect(x, y, w, h, c=(0, 0, 0)):
travel(x, y)
pencolor(c)
fillcolor(c)
begin_fill()
for i in range(4):
forward(w if i % 2 == 0 else h)
right(90)
end_fill()
Ci-dessous donc, le mur en briques, contruit par la fonction wall_brick(-668, -330, 21, 21) :
Difficultés rencontrées
Il ne reste donc plus qu’à dessiner les aiguilles et les faire pivoter au fur et à mesure. Voici donc la fonction qui occupe cette lourde tâche, et qui m’a bien cassé la tête :
def clock_hands(colors_hands, size_hands):
s, m, h, k = get_time("s"), get_time("m"), get_time("h"), 0
update_hours(h, colors_hands[0], size_hands[0])
update_minutes(m, colors_hands[1], size_hands[1])
while True:
update_seconds(s, colors_hands[2], size_hands[2])
sleep(.6 if k < 90 else .5 if k < 180 else .3 if k < 240 else 0)
s += 1
if s == m+2:
update_minutes(m, colors_hands[1], size_hands[1])
if s+1 == (h+1)*5:
update_hours(h, colors_hands[0], size_hands[0])
if s == 60:
s, m, h = get_time("s"), get_time("m"), get_time("h")
update_minutes(m, colors_hands[1], size_hands[1])
update_hours(h, colors_hands[0], size_hands[0])
update_seconds(s, colors_hands[2], size_hands[2], 1)
k += 1
C’est sans doute la fonction la plus compliquée du programme. Les deux paramètres ne sont qu’esthétique, ils permettent de modifier la couleur de chaque aiguille, ainsi que la largeur de chaque aiguille, on ne donc y s’attarder plus que ça. L’objectif est simple, avoir l’heure la plus précise possible, mais en gardant un mouvement des aiguilles fluide. J’ai fait le choix d’appeler la fonction get_time() le moins de fois possible, car elle requiert de faire un nombre extrêmement élevé de requêtes plusieurs fois par secondes. Et faire des requêtes inutiles, ça ralentit le programme… La fonction n’est donc appelée que lors de l’initialisation (avant de rentrer dans la boucle infinie), et lorsque la trotteuse à passe à la soixantième seconde. Nous appelons donc la fonction get_time() environ une fois par minute ; et c’est suffisant. Ensuite, on met à jour la position des aiguilles toutes les secondes… Enfin, c’est un peu plus compliqué que ça. En effet, il faut que le mouvement soit fluide, et donc il faut supprimer toutes les actions inutiles. Sauf que 98% du temps, il n’y a que l’aiguille des secondes qui bouge, celle des minutes et des heures ne bougent beaucoup moins souvent. Donc cela ne sert à rien de mettre à jour ces aiguilles à chaque seconde. On le fait donc à des instants précis. Malgré toutes les optimisations pour fluidifier le rafraichissement, il n’est malheureusement pas parfait. Également, il s’avère que plus le programme tourne longtemps, plus il est lent… Il faut donc adapter la pause de la fréquence en fonction de quand le programme a démarré. Voici à quoi sert la variable k, et la fonction time.sleep(), nous perdons donc beaucoup de précisions au fil du temps. Mais en contrepartie, j’ai mis en place un système pour rerégler automatiquement les aiguilles.
L’image finale
À toi de « jouer » ?!
Tu ne pourras malheureusement pas vraiment t’amuser avec ce programme. À moins que tu veuilles fixer une horloge. Néanmoins, si tu veux savoir comment elle fonctionne exactement, et la voir bouger, n’hésite pas à télécharger le script !
Art
