« La compétence naît de la détermination à passer du stade du novice à celui du débrouillard, forgeant ainsi le chemin de l’expertise »
Par où commencer ?
Dans un premier temps, il faut trouver un thème à dessiner.
Quoi de mieux que de dessiner quelque chose qui nous passionne ; L’automobile pour ma part.
C’est partie pour aller sur paint et essayer des motifs. Puis au bout d’une dizaine d’essais
puisque je ne suis pas un dessinateur professionnel, j’arrive enfin à quelque chose de sympa pour moi.
La Programmation.
Une fois mon modèle prêt, il me reste plus qu’à passer au codage !
La partie noire de ce projet pour moi, mais aussi la plus importante.
J’appréhendais ce moment en tant que débutant, j’avais seulement les simples bases de python et je me demandais comment j’allais faire, mais je me suis rappelé.
« La compétence naît de la détermination à passer du stade du novice à celui du débrouillard, forgeant ainsi le chemin de l’expertise. »
La première ligne était inefficace, mais au fil du codage, je commençais peu à peu à être en confiance.
Le châssis.
La partie la plus facile, mais la plus déterminante pour la suite.
Je commence par définir la fonction « châssis » et au bout de quelques essais, j’arrive enfin à un début de dessin.
Ma première boucle for.
Pour ajouter des petits détails à ma voiture, j’ai décidé d’essayer de faire deux suspensions avec ma première boucle « for i in range »
Au début message d’erreur sur message d’erreur, mais grâce à la persévérance, j’ai réussi ma première boucle for qui m’a redonné motivation à continuer tout en m’apprenant les bases du python.
Un segment verticale où 4 cercle de diamètre 10 se déplace vers le haut de 7 sur l’axe de (y) à chaque range.
Code amortisseur:
def amortisseur():
forward(35)
Y =int(-155)
for i in range(4):
up()
goto(360,Y)
down()
pencolor(Rouge)
pensize(2)
circle(10)
up()
Y = Y+7
On continue sur les boucles for.
Pour continuer, j’ai décidé d’ajouter un peu de contraste au dessin grâce à l’amélioration de mon codage que j’ai pu acquérir au cours du projet.
Au niveau des roues , j’ai ajouté des jantes à bâton avec la fonction (for i in range()) tout en rajoutant quelques détails comme la fumée au niveau de l’échappement et l’aileron a l’arrière de la voiture.
Code fume :
def fume():
Y=int(170)
X=int(20)
P=int(10)
pensize(2)
pencolor(black)
for i in range(5):
up()
goto(Y,X)
down()
circle(P)
X = X+10
P = P+1
for i in range(P):
up()
goto(Y,X)
down()
circle(P)
Y= Y+8
print(fume())
Rendu final.
J’ai commencé ce projet en appréhendant mon niveau en code python.
Mais au fil des nombreuses fonctions définit et de nombreux essais, j’ai réussi à monter en niveau :
Au début, j’arrivais juste à donner des instructions à la tortue.
Pour finir par des boucles avec des instructions.
Donc ce projet m’a permis d’évoluer autant sur moi que mon niveau python m’apprenant qu’avec de la persévérance, on arrive à tous ou presque.
L’image n’est pas superbe, mais montre l’évolution Du débutant en herbe à l’expert débrouillard de python.
L’art génératif est une fusion fascinante entre la créativité humaine et la puissance des algorithmes informatiques, nous vous invitons à plonger dans un univers où la machine devient artiste, créant des œuvres d’une beauté unique et imprévisible.
Notre Projet
Pour ce premier projet de NSI, nous avons décidé de représenter la ville de Riyad en python. Par conséquent, notre image rentre dans le thème de l’Architecture. Nous avons réalisé une ville assez moderne, avec des bâtiments de toutes formes et un soleil hors du commun, notre but étant de faire ressortir la ville luxueuse de Riyad, tout en apportant notre petite touche d’originalité. La vrais question étant comment nous sommes passé d’une simple idée à un résultat splendide ?
Les différentes étapes de la création de l’image
Pour être arrivé à notre résultat final, nous sommes passé par 4 étapes;
Tout d’abord voici le script python qui nous a permis d’obtenir un fond innovateur, les couleurs n’ont pas été choisi par hasard, en effet nous avons souhaité créer une ambiance qui évoque l’originalité sans oubliée le luxe notamment avec des arrondie et un dégradée de couleur reflétant l’étendue de la ville. Nous avons dans un premier temps définie la fonction disque pour dessiner un disque, rayon pour définir la taille des disques, x et y pour les coordonnées du centre et pour le dégradé de couleur nous avons fait appel a Background-color, enfin nous avons utilisé les fonctions arrondi_gauche et arrondi_droit pour dessiner des parties d’arcs.
def disque(rayon, x, y, couleur=(1, 1, 1)):
penup()
goto(x, y-rayon)
pendown()
pencolor(couleur)
fillcolor(couleur)
begin_fill()
circle(rayon)
end_fill()
x, y = (0,-250)
radius = (700)
color = ("#FA1D65")
disque(radius, x, y, color)
t
x, y = (0,-250)
radius = (600)
color = ("#F72367")
disque(radius, x, y, color)
x, y = (0,-250)
radius = (500)
color = ("#F02E6B")
disque(radius, x, y, color)
x, y = (0,-250)
radius = (400)
color = ("#EA3970")
disque(radius, x, y, color)
x, y = (0,-250)
radius = (300)
color = ("#E73F72")
disque(radius, x, y, color)
def arrondi_gauche():
for i in range(120):
left(1)
forward(5/40)
def arrondi_droit():
for i in range(100):
right(1)
forward(5/80)
Le fond est certes beau, mais nous n’avions toujours pas trouvée cette touche de beauté supplémentaire, c’est ce pourquoi nous avons rajouté des étoiles, nous avons utilisé un code python assez simple. Nous avons commencée par définir une nouvelle fonction étoile, puis nous avons placés 125 points grâce à la boucle for i in range ces points sont placés aléatoirement grâce à randint.
def etoile():
pensize(1)
pencolor("white")
for i in range(125):
penup()
x,y = randint(-700,700), randint(-0,700)
goto(x,y)
pendown()
circle(1)
Il est désormais temps de passer, au bâtiment, pour ce qui est des bâtiments nous avons voulus représenter des grattes ciel luxueux de différentes formes, pour ce faire nous avons créer des fonctions bat 1, bat 2 etc … nous avons ensuite définis leur largeur, longueur et hauteur jusqu’à que les bâtiments ressemble à la forme qui nous convenais et enfin nous les avons placés à des endroits différents.
Enfin, il manquait la structure la plus importe, le soleil pour, le soleil on a imaginé un soleil assez original, nous l’avons d’abord dessinée, puis nous l’avons ensuite codée en python, pour ce faire nous nous sommes aidés du concours NumWorks et nous avons utilisé une boucle avec un pas de 1 qui dessine le soleil avec les instructions de forme et de taille donnés.
from math import *
penup()
goto(0, 0)
pendown()
for r in range(20, 80, 1):
penup()
pensize(4 if r % 2 else 1)
for a in range(361):
d = r + 5 * cos(radians(12 * a))
x = d * cos(radians(a))
y = d * sin(radians(a))
goto(x, y)
pendown()
Image final
Les problèmes rencontrés
Il faut savoir que cette image n’est pas aussi facilement réalisable qu’elle ne le paraît, en effet nous avons rencontrés énormément d’obstacle à la création de cette image, notamment lorsque les bâtiments on été créer les tailles on été difficilement ajustable, nous avons dus rajouter plusieurs paramètres pour ajuster la taille des bâtiments ce qui nous a pris plusieurs heure. Nous avons également rencontrés de nombreux code d’erreur heureusement que toute les ressources étais à notre disposition, au final il suffisait de lire.
Notre ressentis sur ce premier projet
Nous avons beaucoup aimé ce premier projet, nous avons pris du plaisir à réaliser le projet, c’est une belle expérience et un coup de coeur, j’ai énormément appris en python pendant ses vacances et je trouve que ce qui est magique c’est d’apprendre en prenant du plaisir.
Dans notre projet de NSI de Novembre 2023, nos enseignants nous ont demandé de créer un programme informatique qui génère une image , en se concentrant sur le concept d’art génératif.
Présentation du sujet:
Partant du tableau des 42 thèmes abordés en classe, notre attention s’est focalisée sur la pendule, symbole puissant du temps. À partir de là, l’idée centrale du projet a émergé : “L’engrenage du temps” visant à représenter à l’aide de turtle notre image du temps .
Sur la représentation que nous avons, on peut observer plusieurs composants tels qu’une pendule, un engrenage, un dégradé et un disque. Nous allons les examiner en détail au fil de la présentation.
Analyse du script:
Le fond :
def degradé():
turtle.colormode(255)
turtle.speed(0)
global compt
global fr
global fg
global fb
while compt != 350 :
turtle.pendown()
turtle.pencolor(fr, fg, fb)
turtle.pensize(3)
turtle.forward(510)
turtle.penup()
turtle.right(180)
turtle.forward(510)
turtle.right(90)
turtle.forward(1)
turtle.right(90)
fr += 1
fg += 1
fb += 1
compt += 1
if compt > 200:
fr -= 1
fg -= 1
fb -= 1
Pour commencer, nous avons programmer le fond avec un dégradé allant du noir au gris.
Dans la fonction dégradé il y a une boucle qui se répète 350 fois dans laquelle la tortue dessine ligne après ligne le dégradé en indentant les variables r,g,b de 1 a chaque ligne sans jamais dépasser la valeur 200.
Engrenages:
def n_engrenage(trait):
turtle.left(90)
turtle.forward(trait * 2)
turtle.right(45)
turtle.pencolor(couleur)
turtle.pensize(8)
turtle.fillcolor(couleur)
turtle.begin_fill()
for i in range(12):
turtle.forward(trait)
turtle.right(120)
turtle.forward(trait)
turtle.left(90)
turtle.end_fill()
La fonction “n_engrenage” dessine l’ engrenage à l’aide du module turtle.
La boucle “for” fait répéter 12 fois une suite d’instructions qui dessinent l’engrenage puis la fonction “turtle.fillcolor” viens définir la couleur de remplissage de l’engrenage qui débute et se finit grâce aux fonctions “turtle.begin_fill” et “turtle.end_fill”.
Pendule:
def disque(rayon, x, y, couleur=(1, 1, 1)):
penup()
goto(x, y - rayon)
pendown()
pencolor(couleur)
fillcolor(couleur)
begin_fill()
circle(rayon)
end_fill()
x = 25
y = 175
radius = 30
color = (255, 255, 0)
disque(radius, x, y, color)
import turtle
pen = turtle
pen.penup()
pen.goto(65, 190)
pen.pendown()
pen.pencolor("black")
pen.goto(175, 350)
import turtle #fonction courbe
t = turtle
t.penup()
t.goto(90,173)
t.pendown()
t.right(50)
for i in range(55):
t.forward(1)
t.right(1)
import turtle #fonction courbe 2
t2 = turtle
t2.penup()
t2.goto(100,180)
t2.pendown()
t2.right(290)
for i in range(75):
t2.forward(1)
t2.right(1)
turtle.hideturtle()
Pour fabriquer la pendule, nous avons commencé avec un plan donné par nos professeurs de NSI. Il comportait plusieurs disques placés de façon aléatoire. Ensuite, nous l’avons simplifié en utilisant les instructions « begin_fill() » et « end_fill() » pour remplir les disques. Ensuite, nous avons ajouté une simple ligne en spécifiant un point de départ et un point d’arrivée. Enfin, nous avons inclus deux courbes pour donner l’impression que la pendule bougeait.
Les problèmes rencontrés:
Parmis les nombreux problèmes rencontrés il y avait que l’exécution de la fonction dégradé prenait très longtemps a finir de s’exécuter (env 1min), pour ne pas perdre temps à relancer tout le code a chaque modification on a trouvé la solution de mettre un “#” devant la ligne qui exécutait la fonction dégradé ce qui permettait de faire passer cette ligne pour un commentaire et de simplement enlever le # quand on voulait exécuter le script complet.
En tant qu’admiratrices de l’album « wiped out ! » du groupe The Neighbourood, notre premier projet en NSI prend une dimension passionnante puisqu’on a choisi de représenter la pochette de cet album qui nous tient particulièrement à coeur.
Le commencement
Pour commencer, nous avons réalisé le fond noir et le cercle blanc qui se situe au centre. Nous avons ensuite placé le texte avec la bonne police d’écriture et la bonne taille au-dessus du cercle blanc. Nous devions aussi reproduire une petite maison à l’envers tout en bas de l’image en commençant par la base puis la cheminée et enfin le toit.
Les vagues et le sol
Pour créer les vagues, nous avons utilisé deux boucles for. Une première boucle sert à dessiner les arcs de cercle qui forment une ligne de vagues, puis une deuxième boucle permet de déplacer la tortue vers le bas pour dessiner la ligne de vagues suivantes. Cette approche répétitive nous permet de créer un motif de vagues continus en descendant d’une ligne à l’autre.
pensize(10)
goto(-300,0)
color("black")
pendown()
setheading(-35)
for i in range(9):
for j in range(11):
circle(35, 70)
circle(-35, 70)
penup()
goto(-300, -20 * (i+1))
pendown()
Il nous fallait aussi un sol qu’on a obtenu grâce à de nombreux cercles pour pouvoir ensuite déplacer la maison.
Le palmier avec les roches
Pour le palmier, on a d’abord dessiné des arcs de cercle pour créer le tronc incliné du palmier puis on a dessiné chaque feuille en utilisant la commande circle() avec des angles spécifiques pour créer la forme des feuilles. Les pierres ont été créées en combinant des formes géométriques superposées les unes aux autres.
L’oiseau
Pour dessiner un l’oiseau, on a dû crée les ailes, le corps, la queue, le bec et la tête de l’oiseau en utilisant des boucles, des lignes et des cercles.
Notre petite touche personnelle
Pour finir, on a rajouté notre petite touche personnelle, un ciel étoilé. Nous avons défini une fonction étoile pour générer 30 étoiles à des emplacements aléatoires.
def etoile():
for i in range(5):
forward(0.5)
pensize(2)
pencolor("white")
for i in range(30):
x = randint(-400, 400)
y = randint(100, 300)
penup()
goto(x, y)
pendown()
etoile()
CONCLUSION
Ce projet nous a permis de réaliser qu’on peut faire de très belle chose juste en ayant les bases de la programmation. On a pris beaucoup de plaisir à voir notre image se construire au fur et à mesure du temps. Cela nous a ouverts de nouvelles perspectives pour des projets futurs et nous avons hâte d’en apprendre davantage pour réaliser des créations encore plus techniques et impressionnantes.
Un paysage où un monument de la culture japonaise se mélange avec un fond naturel est magnifique. Et bien que le Japon soit le pays du soleil, levant nous allons le mettre en valeur avec, cette fois-ci, la lune, à travers des montagnes et des torii. Ces derniers symbolisent un portail entre l’enceinte sacrée et l’environnement profane. C’est pour cette raison qu’il y en a à l’entrée de certains sanctuaires.
Organisation du script
Notre script sera expliqué par étape, de l’arrière plan au premier. La fonction goto sera beaucoup utilisée afin de faire des tracés contrôlés ainsi que pensize() pour la largeur du tracé du stylo, color() pour choisir la couleur du crayon, circle() pour faire un cercle et for i in range pour faire des boucles.
L’arrière-plan
from turtle import*
pensize (42)
color("#FFFFFF")
a = -40
col = ["#FFFFFF","#9BF7F7","#41F9FF","#00CDFF","#008FFF","#0059FF","#003AFF", "#4D00FF","#33079A", "#000000"]
nb_col = len(col)
color("#FFFFFF")
goto(0, 50)
circle(40)
a = 0
for i in range (0,10,1):
goto(0, 40-a)
color(col[i%nb_col])
circle(40+a)
a = a +30
goto(0, 40-a)
circle(40+a)
a = a +30
goto(0, 40-a)
circle(40+a)
a = a +40
Ici, nous montrons que notre script est importé de Turtle, ce module nous permettant de contrôler un crayon pour tracer diverses formes géométriques.
Le fond de notre code n’est pas centré mais c’est fait exprès. Nous avons donc mis la taille du crayon à 42 avec la fonction : pensize (42), ensuite a = -40 nous a servis à déplacer le centre du cercle de base, soit, dans notre cas de le décaler vers la haut. Puis nous avons listé les différentes couleurs utilisées dans tous ces cercles avec col = [ ]. Le goto(0, 50) nous emmènera ensuite aux coordonnées données (donc (0, 50)) puis tracera des cercles de différentes tailles et de différentes couleurs grâce à la fonction cercle circle(40) et à la boucle for i in range (0,10,1):.
Nous comprenons ici que les goto sont et seront à l’honneur de ce script ! Ils sont simples à utiliser et donc à comprendre. La couleur des premières montagnes, elle, est encore une fois définie par color(« #42392C »).
Voici le résultat de tous ces goto ! Nous avons un début de montagne avec quelques imperfections mais pas d’inquiétudes ! Ce script fonctionne par plan donc comme un pochoir. Ici, les goto ont donc servis à diriger le stylo d’un point à un autre jusqu’à ce que nous ayons ce résultat
Ces montagnes sont faites de la même manière que les premières : le changement de couleur avec color(« #6F6556 ») et les goto ! Voyons maintenant le résultat en image…
Et voilà nos montagnes finies ! Mais il reste encore quelques étapes pour donner un sens à notre titre.
Le sol bleu
up()
goto(0,-400)
down()
col = ["#000000","#33079A","#4D00FF", "#003AFF", "#0059FF","#008FFF", "#00CDFF", "#41F9FF","#9BF7F7", "#FFFFFF","#9BF7F7","#41F9FF","#00CDFF","#008FFF","#0059FF","#003AFF","#4D00FF","#33079A","#000000"]
nb_col = len(col)
recup = 0
k = -50
for i in range (0,50):
color(col[i%nb_col])
for i in range (0,3):
k += 40
goto(1000-k,-35)
goto(1300-k,-500)
Comme pour l’arrière-plan, les couleurs sont définies grâce à col = [ ].
Avec l’image, nous pouvons plus facilement comprendre la présence de la boucle for i in range (0,50) qui nous a aidé à répéter tous les traits positionnés en diagonale pour nous éviter de les faire un à un avec des goto par exemple !
Voici le code de nos torii. A chaque nouveau pensize( ), il y en a un nouveau ! Nous avons d’abord le placement du crayon avec up( ), goto( ) et down( ) dans cet ordre là. Cela permet de se déplacer en décidant quand nous voulons écrire.
Cette fois-ci, l’image est sans le fond pour mieux observer le choix de couleur ainsi que les tailles décroissantes.
Le résultat final
Et enfin, notre résultat ! Nous avons également rajouté deux ligne, une verte et une marron pour montrer le début des montagnes mais ces lignes servent aussi à cacher la délimitation qu’il y avait pour les traits droits en diagonale.
Il s’agit d’un projet d’art génératif réalisé en utilisant principalement le module turtle de python . Nous avons décider de générer une Mazda mx-5 aussi appelée Miata sur une route de nuit avec des étoiles générées aléatoirement.
Le script
On commence par importer les modules dont on a besoin pour la suite tout en définissant la taille de l’image grâce au module pillow
from turtle import *
from random import randint
try:
from PIL import *
pillow_installed = True
except:
print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
print("https://nsi.xyz/py2png")
pillow_installed = False
# Uniquement des lettres, des chiffres, un tiret. Rien d'autre.
titre = "MIATA"
# Définir le titre de la fenêtre de turtle + propagande ^^
title(titre+" | Au lycée, la meilleure spécialité, c'est la spé NSI")
# definir la taille de la fenêtre en 720p (Largeur, Hauteur)
# La tortue part du centre, au point de coordonnées (0,0)
setup(800, 700)
# La tortue va à la vitesse du lièvre et active sa cape d'invisibilité
speed(0)
hideturtle()
Image de fond
On génère ensuite l’image en commençant par le fond
On commence par le ciel de nuit et les étoiles
def star():
pensize(3)
seth(randint(0,360))
e = randint(2,6)
color("#F2F3CF")
penup()
goto(randint(-400,400),randint(85,350))
pendown()
for i in range(5):
forward(e)
right(142)
speed(0)
pensize(10000)
hideturtle()
color("#07073C")
forward(10)
for i in range(18):
star()
penup()
goto(-250,300)
pendown()
pensize(2)
begin_fill()
seth(210)
color("#BFC298")
for i in range(
On commence par définir la fonction star() qui nous sert a générer une étoile d’une taille aléatoire a une position elle aussi aléatoire dans la zone qui sera le ciel pour éviter qu’elle finisse cachée par les autres éléments qui seront générés par la suite. Ensuite on fait un fond bleu nuit qui prend l’entièreté de l’écran en mettant une taille de crayon très grande et on génère 18 étoiles en utilisant une boucle qui répète la fonction star() puis on fait un croissant de lune en faisant des boucles donnant des arrondis . Ainsi on obtient cela:
on continue en ajoutant une forêt qui sera derrière la voiture
goto(-400,75)
pendown()
pensize(2)
color("#2C4D20")
begin_fill()
for i in range(3):
seth(45)
forward(77)
right(90)
forward(70)
seth(45)
forward(60)
right(90)
forward(80)
seth(45)
forward(50)
right(90)
forward(43)
right(45)
forward(460)
right(90)
forward(810)
right(90)
forward(455)
end_fill()
Ce code nous permet de générer des triangles de 3 tailles différentes que l’on va remplir fin de donner l’illusion d’une forêt dense en utilisant un vert foncé
Ce code nous permet de faire un grand trait de couleur grise pour représenter la barrière puis il génère un grand rectangle qui représente la route en y ajoutant des bandes blanches, créant ainsi une route.
La voiture
On passe ensuite à la partie la plus importante du script: la voiture
Cette partie nous permet de faire l’avant de la voiture en définissant la fonction pour faire une roue composée d’un pneu et d’une jante, inspiré des jantes BBS et ainsi que la fonction qui servira à faire le phare avant
pensize(1)
color('black')
fillcolor('red')
for i in range (35):
forward(1)
right(0.75)
right(75)
forward(50)
right(90)
for i in range(169):
forward(0.5)
left(1)
right(94)
forward(20)
end_fill()
right(85)
forward(52)
right(163)
penup()
forward(63)
pendown()
jantes()
Résultat final
Il s’agit de la fin du code pour l’image, terminant la Miata en faisant l’habitacle composé du toit de la voiture et d’une fenêtre puis l’arrière de la voiture en rappelant la fonction définie plus tôt afin de faire la seconde roue
Pour conclure on met la dernière partie de code pour exporter l’image en fichier.png
# ============== GENERER DES IMAGES AUTOMATIQUEMENT ==============
if flash:
wn.update()
image = getcanvas()
nom_du_fichier_sans_extension=titre+"_"+hex(randint(2**30+2**25,2**30+2**25+2**24-1))[2:]
# Génère un fichier .ps
image.postscript(file=nom_du_fichier_sans_extension+".ps", colormode='color')
# Ouvre le fichier .ps et génère le fichier .png
try:
psimage = Image.open(nom_du_fichier_sans_extension+".ps")
psimage.load(scale=2)
psimage_resized = psimage.resize((1280, 720))
psimage.save(nom_du_fichier_sans_extension+".png")
print(nom_du_fichier_sans_extension+".png", psimage.size, "sauvegardé dans le dossier")
except:
if not pillow_installed:
print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
print("https://nsi.xyz/py2png")
else:
print("Oops! - 'ghostscript' not installed- RTFM :")
print("https://nsi.xyz/py2png")
exitonclick()
Pour ce premier projet de NSI d’art génératif, nous avons décidé de représenter un micro, un BM 800 avec le module turtle de python.
La vidéo du projet :
Pourquoi le micro ?
Tout simplement car Mathieu fait de la musique plus précisément des instrumentales et Romain lui fait de l’audiovisuel (photos et vidéos). Le micro qui est indispensable dans ces 2 univers. Nous avons choisi le micro BM 800 car pour débuter c’est l’un des meilleurs micros.
Le projet
Pour en revenir au projet, nous avons décidé de faire un micro. Pour cela nous avons utilisé le module turtle ainsi que le module random.
Structure du script
Pour la structure du script nous avons décidé de découper chaque partie de l’image (fond, albums vinyles, cors du micro, prise XLR et bonnette du micro) pour créer des fonctions et pour organiser le script.
Analyse du script
Nous allons analyser le script :
nous allons commencer par par l’appel des modules et la mise en place de turtle :
from turtle import *
from random import randint
"""
Ce fichier est expliqué ici : https://nsi.xyz/py2png
Un autre tutoriel permet de commencer : https://nsi.xyz/tutoriels/decouvrir-le-module-turtle-de-python/
"""
try:
from PIL import Image
pillow_installed = True
except:
print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
print("https://nsi.xyz/py2png")
pillow_installed = False
# Uniquement des lettres, des chiffres, un tiret. Rien d'autre.
# https://learn.microsoft.com/fr-fr/windows/win32/fileio/naming-a-file
titre = "micro bm800 - construit avec turtle"
# Définir le titre de la fenêtre de turtle + propagande ^^
title(titre+" | Au lycée, la meilleure spécialité, c'est la spé NSI")
# definir la taille de la fenêtre en 720p (Largeur, Hauteur)
# La tortue part du centre, au point de coordonnées (0,0)
setup(1280, 720)
# La tortue va à la vitesse du lièvre et active sa cape d'invisibilité
speed(0)
hideturtle()
"""NOUVEAUTE 2023 :
Pour un tracé instantané, sans aucun délai,
il suffit d'affecter la valeur True à la variable "flash" (False par défaut)
mais cela rend le débuggage moins facile
Merci @bebertii
"""
flash = True # False par défaut, on peut mettre True sinon, ou mieux 0x2A
if flash:
wn = Screen()
wn.tracer(0)
Ensuite pour le fond nous avons utilisé une fonction qui se nomme background-color. Nous avons défini avec la couleur bleu marine en hexadécimal.
def fond():
bgcolor("#03224c")
Ce qui nous donne :
Après nous avons fait le corps du micro avec quelques valeurs tel que la couleur, la longueur et la largeur du rectangle. Puis nous avons défini une position à laquelle le corps du micro va se positionner, nous avons tracé un rectangle noir, puis nous avons tracé un trapèze pour représenter le bout du micro.
import turtle
ht()
def corpmicro():
t = turtle.Turtle()
col = ("#000000")
l = 100
la = 200
t.goto(-100,0)
t.fillcolor(col)
t.begin_fill()
t.ht()
for i in range(2):
t.forward(l)
t.right(90)
t.forward(la)
t.right(90)
t.end_fill()
t.begin_fill()
t.penup()
t.rt(90)
t.forward(la)
t.pendown()
t.left(45)
t.forward(40)
t.left(45)
t.forward(44)
t.left(45)
t.forward(40)
t.end_fill()
Ce qui nous donne avec le fond :
Après cela, pour la prise XLR, nous avons réalisé une fonction prise XLR puis nous avons tracé un rectangle gris et nous lui avons donné une position finale.
def prisexlr():
p = turtle.Turtle()
col3 = ("#c4c4c4")
l7 = 44
la6 = 20
p.ht()
p.penup()
p.goto(-72,-228)
p.pendown()
p.fillcolor(col3)
p.begin_fill()
for i in range(2):
p.forward(l7)
p.right(90)
p.forward(la6)
p.right(90)
p.end_fill()
Ce qui nous donne avec le fond et le corps du micro :
Ensuite pour les 2 albums vinyles, nous avons fait 2 fonctions distincts pour chacun des 2 albums vinyles dans lesquels nous avons rentré les même valeurs tel que les couleurs et le rayon des 2 cercles qui compose l’album vinyle ainsi que la longueur du carré. Ensuite nous avons juste modifié les positions des cercles et carrés.
1er album vinyle :
def albumvinyle():
a = turtle.Turtle()
col4 = ("#000000")
col5 = ("#2f4f4f")
col6 = ("#f9429e")
l8 = 80
r = 35
r2 = 35/2
a.penup()
a.goto(-400,300)
a.pendown()
a.fillcolor(col5)
#carton de l'album
a.begin_fill()
for i in range (4):
a.forward(l8)
a.right(90)
a.end_fill()
#vinyle
a.penup()
a.goto(-360,225)
a.pendown()
a.fillcolor(col4)
a.begin_fill()
a.circle (r2)
a.end_fill()
#centre du vinyle
a.penup()
a.goto(-360,242)
a.pendown()
a.fillcolor(col6)
a.ht()
a.begin_fill()
2e album vinyle :
def albumvinyle2():
a = turtle.Turtle()
col4 = ("#000000")
col5 = ("#2f4f4f")
col6 = ("#f9429e")
l8 = 80
r = 35
r2 = 35/2
a.penup()
a.goto(360,-220)
a.pendown()
a.fillcolor(col5)
#carton de l'album
a.begin_fill()
for i in range (4):
a.forward(l8)
a.right(90)
a.end_fill()
#vinyle
a.penup()
a.goto(400,-295)
a.pendown()
a.fillcolor(col4)
a.begin_fill()
a.circle (r2)
a.end_fill()
#centre du vinyle
a.penup()
a.goto(400,-277)
a.pendown()
a.fillcolor(col6)
a.ht()
a.begin_fill()
a.circle (r2)
a.end_fill()
Ce qui nous donne avec le fond, le corps du micro et la prise XLR :
De plus pour la bonnette du micro, nous avons défini un rectangle noir pour faire ressortir le quadrillage gris de la bonnette.
def bonettefond():
#fond permetant de faire un quadrillage noir
b = turtle.Turtle()
col2 = ("#000000")
l2 = 125
la2 = 150
b.penup()
b.goto(-225/2,150)
b.pendown()
b.fillcolor(col2)
b.ht()
b.begin_fill()
for i in range(2):
b.forward(l2)
b.right(90)
b.forward(la2)
b.right(90)
b.end_fill()
Ensuite pour la grille de la bonnette, nous avons fait le quadrillage de la bonnette pour cela nous avons réalisé une fonction qui va permettre de faire des lignes horizontales et verticales.
def bonettegrille():
g = turtle.Turtle()
col3 = ("#c4c4c4")
l3 = 150
la3 = 4
l4 = 125
g.penup()
g.goto(-230/2,150)
g.pendown()
g.fillcolor(col3)
g.begin_fill()
g.ht()
#grille horizontale
for i in range(16):
g.right (90)
g.forward(l3)
g.left(90)
g.forward(la3)
g.left(90)
g.forward(l3)
g.right(90)
g.forward(la3)
g.right(90)
#grille verticale
for i in range(19):
g.right (90)
g.forward(l4)
g.left(90)
g.forward(la3)
g.left(90)
g.forward(l4)
g.right(90)
g.forward(la3)
g.end_fill()
Et pour finir pour les barres de la bonnette, nous avons créer une fonction qui va nous permettre de faire 4 rectangles de longueurs et de largeurs différentes et aussi de positions différentes pour créer les barres de la bonnette.
def barrebonette():
bo = turtle.Turtle()
col3 = ("#c4c4c4")
l5 = 127
la4 = 25
l6 =6
la5 =145
bo.penup()
bo.goto(-230/2,145)
bo.pendown()
bo.fillcolor(col3)
bo.ht()
#première barre horizontale
bo.begin_fill()
for i in range(2):
bo.forward(l5)
bo.right(90)
bo.forward(la4)
bo.right(90)
bo.end_fill()
bo.goto(-230/2,25)
#deuxième barre horizontale
bo.begin_fill()
for i in range(2):
bo.forward(l5)
bo.right(90)
bo.forward(la4)
bo.right(90)
bo.end_fill()
bo.goto(-232/2,145)
#première barre vertical
bo.begin_fill()
for i in range(2):
bo.forward(l6)
bo.right(90)
bo.forward(la5)
bo.right(90)
bo.end_fill()
bo.goto(10,145)
#deuxième barre vertical
bo.begin_fill()
for i in range(2):
bo.forward(l6)
bo.right(90)
bo.forward(la5)
bo.right(90)
bo.end_fill()
Ce qui nous donne avec juste la bonnette et le fond :
De plus, nous avons une fonction très importante qui sert pas à dessiner quelque chose mais elle rassemble toutes les fonctions afin de les mettre dans le bonne ordre. Donc cela nous a permis de faire chacun nos fonctions chez nous et les mettre en commun.
La fractale est couramment sélectionnée comme thème pour la création d’images en raison de sa capacité à produire des motifs d’une complexité infinie et captivante. Cette fusion entre l’art et les mathématiques permet de représenter de manière créative la beauté des structures complexes, qu’elles soient naturelles ou urbaines.
Projet
Donc pour le projet nous avons décider de faire une fractale (l’arbre de Pythagore) sur un dégradé et faire un petit soleil sur le coté haut droit de l’image. Pour cela nous avons mis les script grâce à la bibliothèque turtle.
Le script
Donc pour faire le script nous nous aidons de la bibliothèque turtel. Mais tous les structure construise sont faite grâce à « def ». Nous avons donc du tous les appels a la fin un part un de manier logique et ordonné.
Le script en detailer
from turtle import *
import turtle
from random import randint
from PIL import Image
try:
from PIL import Image
pillow_installed = True
except:
print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
print("https://nsi.xyz/py2png")
pillow_installed = False
# Uniquement des lettres, des chiffres, un tiret. Rien d'autre. https://learn.microsoft.com/fr-fr/windows/win32/fileio/naming-a-file
titre = "Fractale - Un arbre fractaleà"
# Définir le titre de la fenêtre de turtle + propagande ^^
title(titre+" | Au lycée, la meilleure spécialité, c'est la spé NSI")
# definir la taille de la fenêtre en 720p (Largeur, Hauteur, abscisse départ, ordonnée du départ)
setup(1280, 720)
colormode(255)
speed(0)
Tout d’abord « setup(1280, 720) » aident à configurer la fenêtre graphique Turtle pour votre dessin fractal, en lui donnant une taille spécifique (1280×720 pixels)
Puis colormode(255) serre à modifié le mode de couleur pour le rendre plus lisible (de 0 à 255 pour RGB)
Et enfin speed(0) serre à régler la vitesse de dessin pour qu’elle soit la plus rapide possible (vitesse 0).
Cette fonction « fond() » dessine un ciel en dégradé en utilisant une boucle « while » pour créer des bandes horizontales de couleur qui simulent un dégrade sur un ciel . Les composantes de couleur « rciel » « gciel » « bciel » changent progressivement à mesure que la hauteur augmente, créant un effet de transition de couleur réaliste.
La fractale arbre
def arbre(n,longueur):
down()
if n==0:
color('green')
forward(longueur) # avance
backward(longueur) # recule
color('#3f1905')
else:
width(n)
forward(longueur/3) #avance
left(angle) # tourne vers la gauche de angle degrés
arbre(n-1,longueur*2/3)
right(2*angle) # tourne vers la droite de angle degrés
arbre(n-1,longueur*2/3)
left(angle) # tourne vers la gauche de angle degrés
backward(longueur/3) # recule
La fonction arbre à deux paramètres « n" et « longueur » pour contrôler le niveau de récursion et la longueur de la branche.
La condition « if n == 0 » permet de voir le cas de base dais que la profondeur de récursion atteint zéro.
En résumé, ce code utilise la récursion pour faire une fractale d’arbre, créant des branches qui se divise en sous-branches. Le niveau de récursion contrôle le détail de l’arbre, et la longueur de la branche diminue à chaque niveau, formant ainsi une structure d’arbre sur la base d’une fractale.
Le soleil
def soleil():
speed(0)
i = 0
goto(-590, 305)
while i < 200:
down()
color('#FF8C00')
right(90)
forward(55)
right(180)
forward(55)
right(90)
circle(5, 2)
i = i + 1
Ce processus est répété jusqu’à ce que i atteigne 200 créant une série de formes qui se superposent pour former une figure qui ressemble à un soleil.
fond()
hideturtle() # cache la tortue
up() # lève le stylo
right(90) # tourne de 90 degrés vers la droite
forward(300) # avance de 300 pixels
left(180) # fait un demi-tour
goto(0,-350)
angle = 50
color('#3f1905')
arbre(11,700) # exécute la macro
hideturtle() # cache la tortue
up() # lève le stylo
soleil()
On appelle tout les fonction maintenant
Vers le PNG
image = getcanvas()
Fractale=titre+"_"+hex(randint(2**30+2**25,2**30+2**25+2**24-1))[2:]
# Génère un fichier .ps
image.postscript(file=Fractale+".ps", colormode='color')
# Ouvre le fichier .ps et génère le fichier .png
psimage = Image.open(Fractale+".ps")
psimage.save(Fractale+".png")
Observer les étoiles, c’est contempler l’immensité et percer les mystères de l’Univers : « À travers ses télescopes, l’astronomie sonde l’immensité de l’espace, révélant des mondes lointains et des mystères insoupçonnés. Elle nous invite à explorer l’infini, à contempler les astres, les étoiles et à comprendre l’origine de l’univers, suscitant l’émerveillement et la soif de connaissance « (Extrait du livre « Le grand guide de l’astronomie « )
Qu’est ce que l’Astronomie ?
L’astronomie… c’est comme une énorme chasse au trésor dans le ciel, mais avec des étoiles, des planètes et des galaxies ! On apprend à étudier les astres, les étoiles, à comprendre comment elles naissent et évoluent, on étudie aussi leurs propriétés physiques et chimiques.
Pourquoi avons-nous choisi le thème de l’astronomie ?
Tout simplement parce que l’Astronomie est un sujet fascinant, qui captive. Cette science permet d’explorer l’immensité de l’univers, les mystères des étoiles, des planètes et des galaxies. Choisir l’astronomie pour un projet offre une opportunité de découverte, d’apprentissage et d’inspiration.
Les différents problèmes...
Bien évidemment, il y a toujours des problèmes rencontrés lors d’un DM.
Le premier problème a été la communication. En effet, travailler en groupe est toujours compliqué…
Le deuxième problème a été d’assembler les scripts, un message d’erreur apparaissait à chaque fois. La plupart de ces erreurs étaient l’orthographe. En effet, chaque professionnel fait des erreurs…
Ensuite nous avons eu pour les montagnes un bug graphique sur le remplissage qui n’apparaissait que sur le dossier PNG ce qui rendait assez lourd le script sur les montagnes avec « begin_fill() » et « end_fill() »
Analyse du script
Afin d’analyser ce script, nous allons le découper en plusieurs parties, correspondantes aux différentes étapes.
1-Avant de détailler chaque fonction, il faut s’assurer que le script comporte tous les modules nécessaire à la création de l’image.
from turtle import *
from PIL import Image, ImageDraw
from random import randint
titre = "Astronomie - construite avec turtle"
title(titre + " | Au lycée, la meilleure spécialité, c'est la spé NSI")
setup(1280, 720, 0, 0)
speed(0)
goto(0,-200)
On importe les modules PIL (installés auparavant) afin de travailler avec des images, turtle afin de dessiner des formes géométriques sur l’image, et enfin randint afin de générer des nombres aléatoires. Après avoir importé tous ces modules, on définie un titre, ici Astronomie. Ensuite, on définit les titres de la fenêtre graphique. On définit alors la résolution de l’image, ici 1280×720 pixels. On définit aussi la vitesse. Enfin, on place la tortue à la position de départ.
2- Le fond
for i in range(hauteur_degrade):
bleu_fonce = 0.1 + (i / hauteur_degrade) * 0.8
ciel.color(0, 0, bleu_fonce)
ciel.penup()
ciel.goto(x, y)
ciel.pendown()
ciel.forward(largeur_degrade)
y -= 1
Afin de réaliser le fond de l’image, nous avons décidé de commencer la réalisation de l’image par une fenêtre noire similaire au lever d’un rideau, nous avons ensuite réalisé un dégradé de bleu similaire à un coucher de soleil à l’aide de chatgpt.
3-Les étoiles
def etoiles():
for _ in range(42):
speed(0)
penup()
x = randint(-600, 600)
y = randint(-300, 300)
penup()
goto(x, y)
pendown()
dot(8, "orange")
etoiles()
Ne pas faire d’étoile sur une image qui porte sur l’Astronomie, ce n’est pas de l’Astronomie ! Afin de réaliser des étoiles aléatoirement, nous avons utilisé randint. Nous avons bien évidemment pensé a Halloween et pour cela, nous avons réalisé des étoiles en orange.
4-Les astres
Nous avons réalisé deux astres : le soleil et la lune.
Toujours dans le thème d’Halloween, nous avons décidé de faire le soleil rouge.
5-Le sol
Les montagnes, ça ne volent pas, et pour cela, nous avons mis un sol qui est en fait un rectangle en turtle.
def sol():
for i in range(2):
color("black")
forward(1280)
left(90)
forward(250)
left(90)
sol()
6- Les montagnes :
Elles sont seulement constituées de triangle les uns à la suite des autres par une boucle. Nous avons mis à certains moments une légère inclinaison du triangle dans la boucle afin de créer un effet de montée
def triangle():
forward (150)
left (120)
forward (150)
left (120)
forward (150)
goto(-640,-200)
def montagne_plane():
for i in range(50):
begin_fill()
triangle()
left(300)
backward(1)
left(180)
end_fill()
begin_fill()
montagne_plane()
end_fill()
def montagne_ascendante1():
for i in range(50):
begin_fill()
triangle()
left(300)
backward(4)
left(180)
left(0.2)
end_fill()
montagne_ascendante1()
def montagne_ascendante2():
for i in range(10):
begin_fill()
triangle()
left(300)
backward(10)
left(180)
left(2)
end_fill()
montagne_ascendante2()
begin_fill()
#triangle venant juste apres la montée
right(25)
goto(-310,-130)
triangle()
# recalibrage afin de pouvoir continuer l'algorithme
left(300)
backward(10)
left(180)
left(2)
end_fill()
# je fait redescendre legerement la montagne
goto(-290,-200)
for i in range(10):
begin_fill()
triangle()
left(300)
backward(4)
left(180)
end_fill()
for i in range(6):
begin_fill()
triangle()
left(300)
backward(4)
right(5)
end_fill()
left(8)
def montagne_ascendante3():
for i in range(40):
begin_fill()
triangle()
left(300)
backward(7)
left(180)
left(1)
end_fill()
montagne_ascendante3()
begin_fill()
right(25)
goto(150,-130)
triangle()
goto(150,-220)
left(300)
backward(10)
left(180)
left(1)
end_fill()
for i in range(2):
montagne_ascendante1()
Art
