Art
Pour ce premier projet en spécialité NSI, nous avons décidé de produire un paysage inspiré du Grand Canyon. Dans cet article, vous pourrait retrouver toutes les étapes pour créer cette image.
Sommaire
Le projet
Pour ce projet nous avons donc décidé de produire une image d’un paysage inspirée du Grand Canyon. Pour cela nous utilisons le module turtle, le module utilisé pour produire l’image ainsi que le module random. Nous avons également utilisé le script permettant d’exporter une image générée par turtle en .png que vous pouvez retrouver ici.
Au commencement
Nous nous sommes tout d’abord inspirés de l’image ci-dessous, et après en avoir réalisé un rapide croquis à la main nous avons commencé notre script : nous avons créé plusieurs fonctions pour chaque élément, que nous avons ensuite appelées dans un ordre précis à la fin du code.
Structure du script
Pour la structure de notre script, nous avons choisi de réaliser seulement des fonctions (sol, soleil, cactus, montagnes…) et de les appeler à la fin dans un ordre respectif, en y mettant les coordonnées pour celles qui le demande, afin de construire notre image.
Le script étape par étape
Commençons 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
titre = "Paysage - construite avec turtle"
title(titre+" | Au lycée, la meilleure spécialité, c'est la spé NSI")
setup(1280, 720)
colormode(255)
speed(0)
hideturtle()Ce code permet d’appeler les différents modules mais également de vérifier que l’utilisateur a bien installé le module PIL et dans le cas contraire un message d’erreur s’affichera et lui donnera un lien pour installer le module et tout ça sans que le script ne s’arrête. Aprés vérification du bon fonctionnement du script, on met à jour le titre du projet ainsi que sa taille. Enfin on définit le type de couleurs utilisées (R,G,B), la vitesse de la tortue, et on la dissimule.
Commençons par la première fonction : le fond
def fond(): penup() rciel = 0 gciel = 0 bciel = 0 hauteur = -360 goto(-642,-358) pendown() while hauteur != 360: pencolor(round(189 + rciel), round(224 + gciel), round(254 + bciel)) forward(1280) hauteur += 1 goto(-640, hauteur) rciel += (-42/180) gciel += (-7/45) bciel += (-15/500)
Pour le fond on aurait pu utiliser une fonction qui crée directement un rectangle et qui le remplit avec fill_rect, or celui-ci aurait été uni alors que nous souhaitons observé un léger dégradé. Nous avons donc produit un script qui, en faisant avancé la tortue à partir d’un point de départ goto et qui ajoute la différence de chaque couleur (rouge, vert et bleu) entre la couleur de début du dégradé et la couleur de fin, produit un fond dégradé, ici de couleur bleue.
Deuxième, troisième et quatrième fonction : Les sols
def sol1(): penup() goto(-640,-360) fillcolor(65, 72, 51) begin_fill() forward(1280) left(90) forward(175) left(90) forward(1280) left(90) forward(175) left(90) end_fill()
Pour réaliser un effet de profondeur nous avons réalisé un dégradé au niveau des sols en créant trois fonctions différentes sous la forme de la première fonction : sol1(). Pour réaliser le sol on a utilisé de nouveau goto qui permet de placer la tortue avant de la faire avancer pour remplir l’espace.
On répète donc cette fonction en changeant les coordonnées de goto et en éclaircissant la couleur.
def sol2(): penup() goto(-640,-186) fillcolor(101, 109, 74) begin_fill() forward(1280) left(90) forward(50) left(90) forward(1280) left(90) forward(50) left(90) def sol3(): penup() goto(-640,-137) fillcolor(164, 172, 134) begin_fill() forward(1280) left(90) forward(50) left(90) forward(1280) left(90) forward(50) left(90) end_fill()
Ensuite on réalise les montagnes, pour cela on doit créer différentes fonctions, car aucune montagne n’a la même forme.
Montagne 1 :
def montagne1():
#montagne derrière la première
penup()
goto(-560,-190)
fillcolor(158, 78, 39)
begin_fill()
forward(250)
left(120)
forward(50)
right(30)
forward(160)
left(90)
forward(10)
left(90)
forward(50)
right(90)
forward(5)
right(90)
forward(80)
left(90)
forward(140)
left(90)
forward(40)
right(90)
forward(8)
left(90)
forward(120)
right(42)
forward(70)
end_fill()On utilise donc de nouveau goto pour faire déplacer notre tortue et faire en sorte qu’elle dessine a peu près la même forme de montagne que sur la photo. On remplit à l’aide de begin_fill() que l’on arrête à la fin avec end_fill().
On crée ensuite les autres montagnes en changeant la forme et en les éclaircissant légèrement pour créer un effet de profondeur.
Montagne 2 et 3 :
def montagne2():
#montagne derrière la première
penup()
goto(340,-150)
fillcolor(173, 94, 55)
begin_fill()
right(228)
forward(210)
left(120)
forward(30)
right(30)
forward(130)
left(90)
forward(140)
left(90)
forward(9)
right(80)
forward(10)
left(78)
forward(120)
right(40)
forward(2)
end_fill()
def montagne3():
#montagne derrière la première
penup()
goto(-60,-100)
fillcolor(201, 116, 75)
begin_fill()
left(132)
forward(125)
left(120)
forward(50)
right(30)
forward(75)
left(90)
forward(15)
right(45)
forward(7)
left(45)
forward(25)
left(45)
forward(7)
right(45)
forward(26)
left(90)
forward(26)
right(90)
forward(5)
right(90)
forward(10)
left(90)
forward(5)
left(90)
forward(50)
right(50)
forward(5)
end_fill()Ensuite la fonction permettant de dessiner les cactus : On a d’abord attribué les coordonnées x et y à la fonction cactus, qui seront choisies lors de son appel, déterminant alors l’emplacement du cactus sur l’écran, et permettant de l’appeler plusieurs fois a différent coordonnées. On définit ensuite la couleur, la taille et l’épaisseur du trait, on oriente la tortue vers le bas avec la fonction setheading()à 270, puis on commence à dessiner les bras et le tronc du cactus.
def cactus(x, y) :
pencolor(56, 176, 0)
pensize(10)
penup()
goto(x, y)
pendown()
setheading(270)
forward(50)
left(90)
forward(30)
left(90)
forward(50)
penup()
goto(x + 16, y + 16)
pendown()
setheading(270)
forward(125)
On réalise une autre fonction qui dessine un cactus comme le code précédent mais avec des dimensions différentes.
def cactus_petit(x, y) :
pencolor(56, 176, 0)
pensize(5)
penup()
goto(x, y)
pendown()
setheading(270)
forward(25)
left(90)
forward(15)
left(90)
forward(25)
penup()
goto(x + 7, y + 7)
pendown()
setheading(270)
forward(65)
Pour dessiner les virevoltants, que l’on peut retrouver dans le désert : on a tout d’abord attribue les coordonnées x et y (comme précédemment) à la fonction paille, pour l’appeler à différents endroits de l’image. Nous avons ensuite crée une boucle « for i in range » qui dessine des cercles beiges et qui incrémente 1 à chaque nouveau cercle dessiné, réalisant donc, à chaque répétition, des cercles de plus en plus grands.
def paille(x, y) :
penup()
goto(x,y)
pendown()
radius = 0
for i in range(20) :
color(166, 138, 100)
pensize(1)
circle(radius)
radius += 1
Par la suite nous codons la fonction dessinant les nuages : On a (encore une fois) attribue les coordonnées x et y à la fonction nuage, pour l’appeler à différents endroits de l’image ; pour que les deux nuages soient tous les deux horizontaux, on utilise la fonction setheading() en l’orientant à 0 et on dessine ensuite 3 cercles blancs de différentes tailles, chacun d’eux avançant après avoir été dessiné.
def nuage(x, y):
penup()
goto(x, y)
setheading(0)
fillcolor(255, 255, 255)
begin_fill()
circle(25)
forward(40)
circle(35)
forward(35)
circle(18)
end_fill()
Puis celle pour dessiner le soleil : on a tout simplement établit l’emplacement de celui-ci et fait un cercle de couleur jaune.
def soleil() :
penup()
goto(385,250)
fillcolor(224, 161, 66)
begin_fill()
circle(30)
end_fill()
Enfin, la fonction pour dessiner un oiseau simple en bâton : on a établit la couleur et l’épaisseur du trait, orienté la tortue avec la fonction setheading() à 290 pour qu’elle soit bien horizontale, puis fait une boucle qui trace un trait et qui tourne a gauche à deux reprises.
def oiseaux() :
penup()
pencolor(0, 0, 0)
pensize(3)
goto(395, 258)
pendown()
setheading(290)
for i in range(2):
left(50)
forward(15)
Pour produire notre image finale, nous appelons toutes les fonctions (en ajoutant les coordonnées de certaines) :
#appel des fonctions fond(), sol1(), sol2(), sol3(), montagne1(), montagne2(), montagne3() cactus(-600,-150), cactus(500,-240) cactus_petit(230, -100) paille(100, -200), paille(-550, -300), paille(480, -330) nuage(-480, 200), nuage(490, 180) soleil() oiseaux()
Résultat final
Télécharger en .py
