Author: 1ère spé NSI 2023 - 2024

Projets

Cinéma: Matrix et le binaire

« Are you telling me I can dodge bullets ? » Neo, The matrix. Cette citation représente la base de notre projet dans lequel est présenté le personnage Neo au visage hélicoïdal stoppant les balles sur un fond de chiffres binaires aléatoirement positionnés.

I – Le fond

Premièrement, le fond nous semblait être la partie la plus importante du projet. Nous avons donc commencé par poser un fond noir avec les lignes de code suivantes

color('black')
pensize(2000) #peu conventionnel 😅
goto(-635, 350)
forward(700)

Après cela, nous y avons superposé les caractères 1 et 0 que nous avons définis avec le code suivant.

def un():
    pensize(2)
    color('green')
    setheading(60)
    forward(12)
    setheading(270)
    forward(20)

def zero():
    setheading(90)
    circle(8)

Nous avons ensuite créé une suite de boucle pour placer aléatoirement des 1 et des 0 en colonnes. Pour cela, nous avons utilisé le module « random » avec la fonction « random.choice » pour sélectionner aléatoirement un nombre dans une liste prédéfinie, ensuite, une condition nous a permis de placer les chiffres. Pour ordonner ces derniers, une incrémentation aux coordonnées déjà inscrites (définissant la position du premier caractère posé) à la fin de chaque boucle a été nécessaire. Voici le code

y = 330
x = -620
    
for i in range(50):
    penup()
    goto(x, y)
    pendown()
    
    for i in range(20):
        list1 = [1,2]

        if random.choice(list1) == 1: 
            un()
        else:
            zero()
            
        penup()
        goto(x, y - 40 * (i + 1))
        pendown()
        
    x += 25 #incrémentation de la distance entre chaque colonnes (horizontalement)
    

Voici le résultat du fond finalisé :

II – Le personnage, Neo

1 – La main

La main était aussi une partie importante de l’image : elle constitue le point de fuite centrale de l’image, où se dirige toutes les balles. Voici la main, constituée de lignes plus ou moins courtes (doigts) et d’un cercle (paume).

2 – Le corps

Nous avons donc créé le corps d’un homme bâton, avec de simples lignes et un cercle pour la tête. Voici le code :

def corps():
    pensize(5)
    color('white')
    penup()
    goto(0,-70)
    pendown()
    setheading(90)
    left(110)
    forward(180)
    left(25)
    forward(80)
    left(180)
    forward(80)


    setheading(90)
    forward(40)
    right(180)
    forward(150)
    setheading(90)
    right(150)
    forward(90)
    left(180)
    forward(90)
    setheading(90)
    left(150)
    forward(90)
    right(180)
    forward(90)
    setheading(90)
    forward(150)

    right(90)
    circle(50)
    penup()
    setheading(90)
    forward(50)
    pendown()
corp()

Voici le rendu :

3 – La spirale

Pour créer cette spirale, il n’a suffit que de 2 lignes, avec une boucle for :

for i in range(48):
    circle(i,20) # i est donc augmenté a chaque répétition 

Le rendu fut le suivant :

III – Les balles

Pour créer les balles, nous avons créé une fonction, en utilisant les méthodes « begin_fill » et « end_fill » permettant de remplir tout ce que l’on dessine en trait. Voici le code :

def balle():
    pensize(3)
    color('#A9A9A9')
    begin_fill()
    forward(30)
    left(143)
    forward(27)
    left(110)
    forward(15)
    end_fill()
    left(180)
    forward(7)
    color("grey")
    begin_fill()
    circle(10)
    end_fill()

Voici le résultat

Pour créer plus de dynamisme, nous avons opté pour des tirets, encore avec une fonction, appelées (comme les balles) plusieurs fois. Nous avons donc créé une boucle for, se répétant 18 fois :

def tiret():
    for i in range(18):
        pensize(7)
        color("white")
        forward(5)
        penup()
        forward(15)
        pendown()

Pour une balle, nous avons combiné les deux fonctions en les appelant de la sorte :

penup()
left(50)
goto(300,-150) 
pendown()
balle()
penup()
left(90)
forward(30)
pendown()
tiret() 
right(90)

Nous avons répété ce pattern sept fois, en changeant leurs positions (goto).

IV – L’image finale

V – Les problèmes rencontrés

Le seul ‘problème’ qu’on a rencontré fut pour le fond, pour utiliser le module random dans une liste, mais nous avons relu nos exercices sur ce thème et avons facilement trouvé la solution.

VII – Télécharger le .py

Nous vous mettons au défi d’optimiser ce code au maximum, sans changer le rendu.

Projets

Un accord céleste

La musique occupe une place centrale dans la vie contemporaine, transcendant les frontières culturelles et générant des émotions universelles. De nos jours, elle est omniprésente, accompagnant nos moments forts et ponctuant notre quotidien grâce à la facilité d’accès aux plateformes numériques. Au-delà d’un simple divertissement, la musique forge des identités, crée des communautés et offre un refuge émotionnel, devenant ainsi une véritable toile sonore de nos vies modernes.

Pourquoi cet accord ?

Il s’agit d’un do majeur 7 add 11 (Cmaj7add11). C’est un accord rarement utilisé en musique, il est le plus souvent utilisé dans le Jazz. Cet accord est beau à entendre car il est très coloré. Il s’agit d’un accord à 5 notes./

Pourquoi un accord ?

Nous avons choisi de représenter un accord sur une portée car nous sommes tous les trois reliés par la musique. Lowan et Loris faisant principalement du piano et Maceo de la guitare. Nous faisons tous les trois partie de l’option musique qui est l’option la plus intéressante du lycée proposée par l’un des meilleurs professeurs Monsieur CLÉMENTE. Pour cela Nous avons d’abord dessiné La portée à l’aide de ce code ci : 

def draw_staff():
    for i in range(5):
        penup()
        goto(-200, 50 - i * 20)
        pendown()
        forward(400)


def draw_note(x, y):
    penup()
    goto(x, y)
    pendown()
    circle(10)

draw_staff()

On a défini une fonction draw_staff où l’on a intégré une boucle de sorte à ce que la tortue fasse la première ligne, puis reviennent au point de départ pour ensuite descendre et répéter cette opération se répétera 4 autres fois car sur une portée il y a 5 lignes.

pensize(5)
seth(115)
circle(-30, 220)
circle(-50, 220)
forward(70)
circle(50,100)
seth(-145)
circle(50, 58)
forward(200)
circle(-30, 180)
begin_fill()
circle(-10)
end_fill()
hideturtle()

ensuite nous avons dessiné la clef de sol à l’aide de ce code ci-dessus. On a d’abord commencé par définir la taille de la clef et mis les valeurs correspondantes pour faire les bonnes boucles.

Pourquoi ce fond ?

Pour le fond nous avons représenté des étoiles aléatoirement disposées sur un fond dégradé bleu et noir qui représente le ciel. Nous nous sommes inspirés de l’album Geography de Tom Misch puis nous avons changé les couleurs pour arriver à un dégradé de couleur bleu. Nous nous sommes inspirés du travail d’un première de la spécialité NSI.

Album de Tom Misch : https://www.youtube.com/watch?v=dA9mzvPtp5I

goto(-400, -300)
pendown()

for i in range(600):
    pencolor(0,0, 255-round((i/(600/255))))
    forward(800)
    goto(-400,-300+i)

Analyse du script :

Le script se divise en 3 parties : Il y a la première partie, les étoiles sur le fond dégradé, ensuite par dessus nous avons rajouté la portée blanche avec les notes et pour terminer une clef de sol.

Le rendu final du script : 

voici l’entièreté de notre script python qui va générer notre image ; « l’accord céleste »

from turtle import *
from random import *
Screen()
setup(800, 600)
penup()
colormode(255)
speed(0)
goto(-400, -300)
pendown()

for i in range(600):
    pencolor(0,0, 255-round((i/(600/255))))
    forward(800)
    goto(-400,-300+i)
color("white")
def etoile(taille):
  for i in range(5):
    pensize(uniform(0.1, 2.5))
    forward(taille)
    right(144)
for i in range(200):
  x = randint(-400, 400)
  y = randint(-250, 250)
  couleur = randint(0, 2)
  if couleur == 0:
    color("#D68B0F")
  elif couleur == 1:
    color("#EBEBAB")
  else :
    color("#A7C706")
  penup()
  goto(x, y)
  pendown()
  taille = uniform(0.1, 2)
  etoile(taille)


shape("arrow")
color("white")
speed(0)

def draw_staff():
    for i in range(5):
        penup()
        goto(-200, 50 - i * 20)
        pendown()
        forward(400)


def draw_note(x, y):
    penup()
    goto(x, y)
    pendown()
    circle(10)

draw_staff()


draw_note(-150, -30)
penup()
goto(-159, -30)
pendown()
setheading(270)
backward(100)


draw_note(-100, 10)
penup()
goto(-100, 10)
pendown()
setheading(270)
backward(100)

draw_note(-50, -10)
penup()
goto(-50, -10)
pendown()
setheading(270)
backward(100)

draw_note(0, -30)
penup()
goto(0, -30)
pendown()
setheading(270)
backward(100)

draw_note(50, -50)
penup()
goto(50, -50)
pendown()
setheading(270)
backward(100)
penup()
goto(-159, 70)
pendown()
left(124)
forward(71)
penup()
goto(-300, 0)
pendown()

pensize(5)
seth(115)
circle(-30, 220)
circle(-50, 220)
forward(70)
circle(50,100)
seth(-145)
circle(50, 58)
forward(200)
circle(-30, 180)
begin_fill()
circle(-10)
end_fill()
hideturtle()
Art

Le micro BM 800

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.

def immagemicro():
    fond()
    corpmicro()
    bonettefond()
    bonettegrille()
    barrebonette()
    prisexlr()
    albumvinyle()
    albumvinyle2()



immagemicro()

L’image finale

Art

Un arbre fractale

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).

Le fond:

def fond():
    penup()
    rciel = 0
    gciel = 0 
    bciel = 0
    hauteur = -360
    goto(-642,-358)
    pendown()
    while hauteur != 360:
        pencolor(round(239 + rciel), round(200 + gciel), round(209 + bciel))
        forward(1280)
        hauteur += 1
        goto(-640, hauteur)
        rciel += (-29/180)
        gciel += (2/45)
        bciel += (7/720)

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")

Téléchargement du programme

Art

Astronomie : Voyage dans les étoiles

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.

def planète():
    speed(0)
    penup()
    goto(300, 250)  
    pendown()
    color("red")
    begin_fill()
    circle(50)  
    end_fill()
hideturtle()
planète()
penup()
goto(0,-200)
pendown()
fillcolor("white")
begin_fill()
circle(180)
end_fill()

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()

L’image finale

Le fichier.py