La Patrouille de France

Projets

Pour ce premier projet de NSI, nous avons décider de prendre comme thème une image de la Patrouille de France, vous pourrez retrouver ici les démarches par lesquelles nous sommes passées.

Notre vidéo :

Le Fond :

Tout d’abord pour obtenir notre image nous avons créer un fond dégradé bleu :

n = 350
s = (0, 0, 139)  
e = (173, 216, 230)  
w, h = 1280, 720


def degrade(st, end, step, t_step):
    return st + (end - st) * step / t_step

Pour obtenir ce résultat nous avons donc créer les paramètres de notre dégradé, il y en a 4 : le nombre de ligne que va faire la tortue (n) ; la couleur de départ (s) ; la couleur de fin (e) ; La longueur et la largeur (w, h) . Afin que la tortue change petit à petit de couleur, on créait la fonction degrade, qui va donc utiliser 3 paramètres : le nombre de ligne que va faire la tortue ; la couleur de départ ; la couleur de fin et effectuer une opération mathématique.’

for i in range(n):
    r=int(degrade(s[0], e[0], i, n))
    g=int(degrade(s[1], e[1], i, n))
    b=int(degrade(s[2], e[2], i, n))

    screen.colormode(255)
    pen.color(r, g, b)

Ici, on calcule la nuance de bleu qui va être utilisé à chaque ligne du dégradé.

    screen.colormode(255)
    pen.color(r, g, b)

screen.colormode(255) : Cette fonction définit le mode de couleur de l’écran sur une échelle de 0 à 255. Par défaut, Turtle utilise une échelle de couleur de 0 à 1 (où chaque couleur est une valeur décimale entre 0 et 1).

pen.color(r, g, b) : Cette fonction définit la couleur du stylo en utilisant trois valeurs pour le rouge (r), le vert (g), et le bleu (b). Ces valeurs doivent être comprises entre 0 et 255.

 pen.goto(-w/2, h/2 - i * (h / n))
    pen.begin_fill()
    for _ in range(2):
        pen.forward(w)
        pen.right(90)
        pen.forward(h / n)
        pen.right(90)
    pen.end_fill()

Ici, on délimite le rectangle dans lequel le dégradé doit être créer.

Les avions :

Ensuite nous avons créer une fonction avion qui créer nos avions :

def avion(x,y):
    pen.pu()
    pen.goto(x,y)
    pen.pd()
    pen.color("#9f9f9f")
    pen.begin_fill()
    pen.goto(x-7,y-30)
    pen.goto(x-10,y-60)
    pen.goto(x-80,y-160)
    pen.goto(x-10,y-160)
    pen.goto(x-10,y-175)
    pen.goto(x,y-175)
    pen.goto(x+10,y-175)
    pen.goto(x+10,y-160)
    pen.goto(x+80,y-160)
    pen.goto(x+10,y-60)
    pen.goto(x+7,y-30)
    pen.goto(x,y)
    pen.end_fill()

Tout d’abord, nous avons créé une fonction avion. Dans cette partie du code, nous dessinons la silhouette de l’avion à l’aide de goto(), nous lui donnons une couleur avec color(), puis nous la remplissons avec begin_fill() et end_fill().

	pen.pu()
    pen.goto(x-10,y-60)
    pen.pd()
    pen.color("#999999")
    pen.begin_fill()
    pen.goto(x-10,y-160)
    pen.goto(x-80,y-160)
    pen.goto(x-10,y-60)
    pen.end_fill()
    pen.pu()
    pen.goto(x+10,y-60)
    pen.pd()
    pen.begin_fill()
    pen.goto(x+10,y-160)
    pen.goto(x+80,y-160)
    pen.goto(x+10,y-60)
    pen.end_fill()

Ici, nous façonnons l’ombre sur les ailes en leur donnant une couleur plus sombre,

	pen.pu()
    pen.goto(x,y-20)
    pen.pd()
    pen.color("#606060")
    pen.begin_fill()
    pen.goto(x-5,y-40)
    pen.goto(x-5,y-50)
    pen.goto(x,y-70)
    pen.goto(x+5,y-50)
    pen.goto(x+5,y-40)
    pen.goto(x,y-20)
    pen.end_fill()

Cette partie nous permet de faire le cockpit,

    pen.pu()
    pen.goto(x-40,y-150)
    pen.pd()
    pen.color("red")
    pen.begin_fill()
    pen.circle(10)
    pen.end_fill()
    pen.pu()
    pen.goto(x-40,y-147)
    pen.pd()
    pen.color("#ffffff")
    pen.begin_fill()
    pen.circle(7)
    pen.end_fill()
    pen.pu()
    pen.goto(x-40,y-144)
    pen.pd()
    pen.color("blue")
    pen.begin_fill()
    pen.circle(4)
    pen.end_fill()
    pen.pu()
    pen.goto(x+40,y-150)
    pen.pd()
    pen.color("red")
    pen.begin_fill()
    pen.circle(10)
    pen.end_fill()
    pen.pu()
    pen.goto(x+40,y-147)
    pen.pd()
    pen.color("#ffffff")
    pen.begin_fill()
    pen.circle(7)
    pen.end_fill()
    pen.pu()
    pen.goto(x+40,y-144)
    pen.pd()
    pen.color("blue")
    pen.begin_fill()
    pen.circle(4)
    pen.end_fill()

Et pour finir, ce long script nous permet de faire les cocardes tricolores françaises.

Les traînés :

Afin d’avoir trois traîner au couleur de la France, nous avons créer trois fonction : traine_bleu ; traine_rouge ; traine_blanche.

def traine_bleu(x,y):

    pu()
    goto(x,y)
    pd()
    begin_fill()
    color("#00034e")
    goto(x-15,y-560)
    goto(x+15,y-560)
    goto(x,y)
    end_fill()
    pu()
def traine_blanc(x,y):

    pu()
    goto(x,y)
    pd()
    begin_fill()
    color("#ffffff")
    goto(x-15,y-560)
    goto(x+15,y-560)
    goto(x,y)
    end_fill()
    pu()
def traine_rouge(x,y):

    pu()
    goto(x,y)
    pd()
    begin_fill()
    color("#c30000")
    goto(x-15,y-560)
    goto(x+15,y-560)
    goto(x,y)
    end_fill()
    pu()

Pour créer les traîners, nous avons simplement créé une fonction de base où nous avons changé la couleur.

Les problèmes rencontrés :

Lorsque nous avons voulu générer nos avions avec les traînées à l’arrière nous avons obtenue l’image suivante :

Le problème venait du fait que nous avions dessiner les avions avant de dessiner les traînées. Donc les traînées sont apparues par dessus les avions.

Nos sources :

Afin de réaliser le code nous avons utiliser le site python.org, ainsi que nos connaissances. Nous avons aussi pris le temps de regarder les travaux des années précédant de la catégories art.

Image finale :

Voici le moment tant attendu l’image finale :

Télécharger notre script :

La patrouille de FranceTélécharger