Art
Pour notre premier projet de NSI, qui a pour sujet l’art génératif, nous avons décidé de créer une image d’un coucher de soleil en bord de mer, en essayant de capitaliser un maximum sur l’ambiance générale de l’image, pour la rendre intéressante et détaillée. Cet article va vous présenter point par point le processus de création de ce projet. Bonne lecture !
Sommaire
- 1 La vidéo de présentation du projet :
- 2 Les autres pistes du projet
- 3 Déroulement du projet
- 4 Les étapes de création de notre image
- 5 Le Ciel
- 6 La Mer
- 7 Le Soleil
- 8 La Plage
- 9 Les Reliefs
- 10 Les Palmiers
- 11 Le Bateau
- 12 Les Oiseaux
- 13 Difficultés rencontrées
- 14 Résultat final
- 15 Le script en .py
- 16 Articles similaires
La vidéo de présentation du projet :
Les autres pistes du projet
De nombreuses pistes ont été explorées quant à quoi faire comme projet de NSI. Il nous fallait trouver quelque chose de complexe, mais pas infaisable, ainsi que parlant et pas complètement hors sujet.
Nous d’abord pensé à faire une ville futuriste, tirée du jeu vidéo Cyberpunk 2077, mais l’idée a été abandonnée de peur de ressembler au Paysage Synthwave. Puis nous nous sommes tournés vers la musique et à des albums tels que In Rainbows de Radiohead, In Absentia de Porcupine Tree, ou encore Ænima de TOOL, mais ces possibilités ont été rejetées de peur de ne pas être à la hauteur de l’œuvre originale.
Alors, nous nous sommes aventurés dans les anciens projets d’élèves avant de tomber sur l’idée d’un paysage et enfin de la mer, car c’est un environnement qui évoque à la fois de la nostalgie et de la joie et qui parlera donc au plus grand nombre, mais qui représente également un certain challenge à représenter et donc, l’idée idéale.
Déroulement du projet
Ce projet a été conçu sur les deux semaines des vacances de la Toussaint 2024, avec les 3/4 du temps entièrement consacré au code et l’image, et les quelques derniers jours à la réalisation de cet article, ainsi que de la vidéo. Nous avons utilisé des IDE tels que Thonny et VS Code, ainsi que de l’outil en ligne Replit, afin de partager notre code, et tester nos fonctions.
Les étapes de création de notre image
Afin d’avoir une meilleure idée des couches et des objets dont notre image allait avoir besoin, nous avons commencé ce projet par un brouillon. Et bien que l’image finale ne ressemble en rien à ce qui était prévu, cela nous a quand même permis de commencer notre code et d’en construire la structure et les fonctions par la suite.
Une des premières choses que nous avons faite est une fonction essentielle de notre code, nommée go() et qui permet à la turtle de se « téléporter » sans laisser de trace, ce qui s’avèrera très utile pour la lisibilité du code, en plus d’économiser des lignes.
def go(x, y) :
penup()
goto(x, y)
pendown()Le Ciel
Après cela nous avons créé notre fonction ciel(), sûrement une des plus complexes du code, qui se compose de trois boucles. La première créée un fond ayant un dégradé de couleurs rappelant un ciel lors d’un coucher de soleil. Ici, il a été difficile de trouver une bonne manière de faire un dégradé qui prenne bien en compte nos deux couleurs, et beaucoup d’essai ont été nécessaires pour trouver une bonne formule.
Ensuite, la seconde fait apparaitre des étoiles avec le module random. Enfin, ainsi que des raies de couleur. L’utilisation de la fonction randint() du module random permet de faire en sorte que les étoiles sont à des positions quasiment toujours différentes.
Enfin, la dernière boucle a été trouvée de manière complètement accidentelle. En faisant des recherches pour la formule de la première boucle, nous nous sommes rendu compte qu’espacer l’ordonnée du retour « à la ligne », à la ligne 15, permettait des stries dans le ciel, ce qui constitue au final un détail important de notre image.
def ciel(col1, col2, larg, long) :
colormode(255)
h = -long / 2 + long // 6
go(-larg / 2, h)
for i in range(long) :
r = col1[0] + (col2[0] - col1[0]) * i / long
g = col1[1] + (col2[1] - col1[1]) * i / long
b = col1[2] + (col2[2] - col1[2]) * i / long
pencolor(int(r), int(g), int(b))
forward(larg)
go(-larg / 2, h+i)
for i in range(300) :
x = randint(-640, 640)
y = randint(-360, 360)
taille = randint(1, 4)
c = randint(200, 240)
color(c,c,c)
go(x, y)
dot(taille)
for i in range(long) :
r = col1[0] + (col2[0] - col1[0]) * i / long
g = col1[1] + (col2[1] - col1[1]) * i / long
b = col1[2] + (col2[2] - col1[2]) * i / long
pencolor(int(r), int(g), int(b))
forward(larg)
go(-larg / 2, h+i*10)
Le résultat de cette fonction est le suivant :
La Mer
La fonction de la mer est plus ou moins la même que celle du ciel, mais avec des valeurs différentes, retournant le dégradé, et le plaçant bien plus bas.
def mer(col1, col2, larg, long) :
h = -270
go(-larg / 2, h)
for i in range(long) :
r = col1[0] + (col2[0] - col1[0]) * i / long
g = col1[1] + (col2[1] - col1[1]) * i / long
b = col1[2] + (col2[2] - col1[2]) * i / long
pencolor(int(r), int(g), int(b))
forward(larg)
go(-larg / 2, h+i)
On obtient alors ce dégradé, bien plus comprimé que le précédent, mais dont la partie inférieure est principalement cachée par les reliefs.
Le Soleil
Le Soleil a sûrement été la fonction la plus bizarre à créer de ce projet. En effet, bien qu’elle soit assez courte, trouver la bonne formule pour les couleurs des anneaux a demandé beaucoup d’essai sans trop savoir où aller, comme pour le ciel et son dégradé de couleur.
C’est après avoir créé un cercle central qu’elle change les couleurs et repart d’un point plus bas pour tracer un cercle plus grand, toujours de la même valeur (i*10) et que nous avons simplifié sous la forme d’une variable t, pour des questions de lisibilité.
def soleil(x, col) :
go(0, -250)
color(col)
begin_fill()
circle(x)
end_fill()
for i in range(5) :
t = i * 10
r = max(col[0] - t, 0)
g = max(col[1] - t * 3, 0)
b = 100 - t * 2
color(r, g, b)
width(12)
go(0, -250 - t)
circle(x + t)Nous avons aussi rajouté des effets sur la mer qui représente les reflets du soleil. Pour cela nous avons utilisé une boucle ainsi qu’une structure conditionnelle, dans une nouvelle fonction, appelée reflets(), qui est assez simple et qui sera par ailleurs réutilisée plus tard pour les reflets du bateau :
def reflets(x, y, larg, col, taille, n) :
setheading(0)
for i in range(n) :
if n==7 :
pencolor(col)
pensize(taille)
go(x - larg // 2, y - i * 20)
forward(larg)
larg -= 50 * i / 2
taille -= 2
else :
pencolor(col)
pensize(taille)
go(x - larg // 2, y - i * 8)
forward(larg)
larg -= 50 * i / 2
taille-=1
On obtient alors ce résultat, de notre soleil sans mer en dessous :
La Plage
Pour faire la plage nous avons créé une fonction nommée plage où nous y avons créé une autre fonction nommée arrière_plan. La fonction fait se téléporter la tortue grâce à la fonction go() à des coordonnées qui sont contenues dans une liste, qui fut très laborieuse à faire (comme celles à venir). Ensuite, grâce aux fonctions begin_fill() et end_fill(), la forme créée est remplie d’une couleur contenue dans les structures conditionnelles.
def plage(x, y) :
def arrière_plan(x, y) :
go(x, y)
color(40, 25, 25)
points = [(x, y + 190),(x + 200, y + 150), (x + 250, y + 125), (x + 500, y + 100), (x + 642, y + 100), (x + 800, y + 80), (x + 1280, y+ 130), (x + 1280, y)]
begin_fill()
for x, y in points:
go(x, y)
end_fill()
arrière_plan(x, y+75)
go(x, y)
begin_fill()
for i in range(60) :
pensize(10)
color(28, 22, 19)
forward(1280)
y += 2
go(x, y)Les Reliefs
Pour créer cet effet de profondeur sur la plage nous avons utilisé une fonction utilisant le même principe que la fonction plage(). Le code reste très proche de l’autre fonction avec quelques différences. Par exemple, le paramètre n permet de choisir quelles listes, couleur et coordonnées le code choisi, afin de ne pas avoir à recréer des fonctions inutilement. Puis, le code parcours chaque point dans l’ordre et remplit la forme.
def reliefs(x, y, n) :
if n == 1 :
x,y = -640, -250
go(x, y)
color(28, 22, 19)
points = [(x, y + 150), (x + 100, y + 100), (x + 200, y + 50), (x + 300, y + 30), (x + 400, y + 70), (x + 450, y + 60), (x + 475, y + 50), (x + 500, y + 40), (x + 600, y + 10), (x + 642, y + 20), (x + 700, y + 30), (x + 800, y + 30), (x + 900, y + 30), (x + 1000, y + 50), (x + 1100, y + 70), (x + 1200, y + 100), (x + 1280, y + 150), (x + 1280, y)]
begin_fill()
for x, y in points:
go(x, y)
end_fill()
if n == 2 :
x,y = -640, -400
go(x, y)
color(20, 14, 11)
points = [(x, y + 250), (x + 200, y + 150), (x + 600, y + 125), (x + 900, y + 175), (x + 1200, y + 200), (x + 1280, y + 150), (x + 1280, y)]
begin_fill()
for x, y in points:
go(x, y)
end_fill()
if n == 3 :
x,y = -640, -360
go(x, y)
color(28, 19, 14)
points = [(x, y + 150),(x+250, y + 100),(x+750, y + 50), (x + 1280, y+150), (x + 1280, y)]
begin_fill()
for x, y in points:
go(x, y)
end_fill()Nous l’avons appelé un total de 3 fois, créant ainsi une profondeur plus conséquente, même sans perspective et points de fuites concrets dans l’image.
reliefs(-640,-250, 1) reliefs(-640,-400, 2) reliefs(-640, -360, 3)
Avec la fonction plage() et des fonctions reliefs() combinées on obtient ce résultat :
Les Palmiers
Jusqu’ici, notre plage au bord de la mer ressemblait plus à un amas de rocher sans vie qu’au résultat escompté. Ainsi, pour donner un côté plus exotique à notre image nous avons décidé de rajouter des palmiers. Ils sont créés à l’aide de 2 fonctions : palmier() et feuille(). La fonction palmier permet de créer la base du palmier (le tronc). On remarque le paramètre r, qui sert à préciser l’inclinaison du palmier (0 = droite, 1 = gauche). Cette fonction est principalement composée de goto() qui ne sont pas remplaçables par notre fonction go() car elle ne tracerait pas les bords noirs.
À la fin de cette fonction nous appelons la fonction feuille. Elle crée des demi-cercles créant ainsi des feuilles de palmier avec les for angle in angles, ainsi que des détails à l’intérieur de celles-ci avec les for offset in offsets, qui constituent au final un détail essentiel de notre image.
Nous l’appelons 2 fois dans la fonction palmier, une fois pour le côté gauche et une autre fois pour le côté droit.
def palmier(x, y, col, r) :
go(x, y)
color(col)
pensize(3)
fillcolor(51, 32, 3)
begin_fill()
for i in range(10):
if r > 0 :
right(1)
goto(x, y + 40)
goto(x + 40, y + 38)
goto(x + 40, y)
goto(x, y)
go(x, y + 40)
x += 2
y += 40
else :
left(-7)
goto(x, y + 40)
goto(x + 40, y + 38)
goto(x + 40, y)
goto(x, y)
go(x, y + 40)
x -= 4
y += 40
end_fill()
x, y = pos()
go(x + 20, y - 1)
color(0, 0, 0)
fillcolor(58, 35, 5)
begin_fill()
circle(40)
end_fill()
go (x+20, y+41)
feuilles(150,0, 0)
feuilles(-160,1, 0)def feuilles(long, dir, i):
x, y = pos()
if dir == 1:
angles = [45, 90, 360]
offsets_g = [99, -216, 189]
offsets_d = [-101, -146, -192]
col = [(11, 97, 1), (10, 77, 2), (5, 59, 0)]
for angle in angles:
color(col[i])
setheading(angle)
begin_fill()
circle(long, 110)
end_fill()
go(x, y)
i += 1
for offset in offsets_g:
color(6, 44, 2)
setheading(angle + offset)
circle(170, 92)
go(x, y)
for offset in offsets_d:
color(6, 44, 2)
setheading(angle + offset)
circle(190, -85)
go(x, y)
elif dir == 0:
angles = [135, 180, 90]
col = [(11, 97, 1), (10, 77, 2), (5, 59, 0)]
for angle in angles:
color(col[i])
setheading(angle)
begin_fill()
circle(long, 110)
end_fill()
go(x, y)
i += 1
Et voici les deux palmiers que l’on obtient à la fin de l’exécution du script. Ils sont très légèrement différents pour éviter de créer une répétition :
Le Bateau
Pour représenter le bateau nous avons utilisé 2 fonctions : bateau() et reflets() décrite précédemment, avec des paramètres différents. Le script du bateau est assez peu lisible, mais il marche, et c’est le plus important. Il se constitue principalement de fonctions basiques de turtle afin de tracer les formes du bateau.
def bateau(x, y) :
setheading(0)
go(x,y)
color(0,0,0)
pensize(3)
begin_fill()
forward(40)
left(45)
forward(20)
a, b = pos()
setheading(0)
go(x,y)
left(135)
forward(20)
go(a,b)
go(x,y)
go(a-40,b)
setheading(90)
forward(40)
right(135)
forward(40)
go(a-40,b)
end_fill()
hideturtle()
On obtient alors un petit bateau au loin comme celui-ci, qui n’est pas très détaillé, mais qui en donne assez bien l’illusion :
Les Oiseaux
Enfin, en touche finale, pour donner un côté vivant à notre image nous avons rajouté des oiseaux en forme de V. Les oiseaux ont un placement aléatoire grâce à la fonction randint() du module random et l’angle des ailes, ainsi que leur couleur (bien que donnant une différence très subtile) sont aléatoire, ce qui permet à l’image au global d’être moins monotone.
def oiseaux (n):
for i in range(n) :
x = randint(0, 250)
y = randint(0,200)
a = randint(2, 4)
taille = a * 10
angle = randint(50, 70)
c = randint(0, 30)
go(x,y)
pensize(a)
color(c,c,c)
setheading(135)
circle(taille, angle)
go(x,y)
setheading(45)
circle(-taille, angle)
hideturtle()Ce script nous a donné comme résultat une image similaire à celle-ci, mais qui ne sera jamais vraiment la même, à cause des paramètres aléatoires de cette fonction. Cette dernière fonction conclue alors le principal de notre code !
Difficultés rencontrées
Durant ce projet, nous nous sommes confrontés à de nombreuses difficultés techniques, mais qui nous auront au final permis d’améliorer nos compétences en python.
Par exemple, un des premiers problèmes que nous avons dû résoudre fut celui du dégradé de couleur, qui a mis beaucoup de temps avant de marcher correctement, et de nombreux essais. De même, la gestion de la position aléatoire des oiseaux a été un défi, nécessitant de nombreux essais, car ils avaient tendance à se superposer ou à se cacher derrière le palmier droit. Le placement des reliefs et le détail des feuilles de palmiers ont aussi pris du temps, car ils demandaient des ajustements minutieux pour que l’image gagne en cohérence. Ce fut d’ailleurs aussi le cas avec les détails des feuilles de palmiers.
En résumé, le déboggage du code a pris du temps, mais il était nécéssaire pour parvenir à notre image finale !
Résultat final
C’est à la toute fin du code que nous appelons toutes ces fonctions dans un ordre précis (du plus éloigné au plus près) pour créer l’image finale :
ciel((255, 154, 92), (154, 0, 255), 1280, 1000) soleil(250, (255, 203, 61)) mer((154, 0, 254), (255, 154, 92), 1280, 168) reflets(0, -89, 425, (255, 203, 61), 14, 7) plage(-640, -360) reliefs(-640,-250, 1) oiseaux(6) reliefs(-640,-400, 2) palmier(-425, -275, (0, 0, 0), 1) palmier(380, -250, (0, 0, 0), -1) reliefs(-640, -360, 3) bateau(125, -96) reflets(145, -105, 40, (0, 0, 0), 4, 3)
Tout ce code fut par la suite inséré dans le code fourni par nos enseignant et qui permet d’exporter cette image en .ps dans le format .png. Le code python complet (d’environ 390 lignes) se trouve plus bas, téléchargeable en version compressée.
Le script en .py
Voici le script python si vous voulez vous aussi vous amusez à le manipuler, ou simplement regarder sa construction dans son ensemble.
Merci d’avoir lu cet article ! Nous espérons qu’il vous aura été utile !
