Author: Pierre B.

Tutoriels

Musique : Apprendre la MAO

La musique c’est génial. Écouter de la musique c’est fabuleux. Et faire de la musique c’est encore mieux. Sauf que c’est dur, et long, et la contrainte de l’argent n’aide pas forcément. Pourtant, grâce à la technologie, il est désormais possible de faire de la musique depuis sa chambre, sans dépenser le moindre centime. Dans ce tutoriel, je vais donc vous montrer pas à pas les bases de la production musicale, pour permettre à quiconque le voudra de se jeter à l’eau.

Vidéo du tutoriel

Introduction à la MAO

On va commencer par les bases : la MAO (Musique Assistée par Ordinateur) est un terme qui regroupe tout ce qui touche à la création de musique à l’aide d’outils informatiques.

C’est un domaine qui est devenu essentiel à la production musicale de nos jours et qui est également devenu très simple d’accès durant ces dernières décennies. En effet, là où la MAO n’apparaissait que dans des studios d’enregistrement professionnels, aujourd’hui n’importe qui peut se lancer. Voici le strict minimum dont vous aurez besoin :

• Un ordinateur : Vous allez avoir besoin d’un PC/Mac relativement puissant pour supporter le logiciel, qui est souvent assez impactant sur le processeur.

• Un casque ou enceintes : Pour un rendu sonore fidèle, un casque fermé ou des enceintes de monitoring sont recommandés. Sans ça, il sera très difficile, voire impossible, d’obtenir un résultat sonore satisfaisant, surtout au moment du mix dont on reparlera plus tard.

• Et enfin un logiciel : Le logiciel, appelé DAW, vous sera indispensable pour créer, enregistrer et même mixer. Il en existe un très grand nombre, donc vous devrez choisir le vôtre en fonction de vos préférences en terme de workflow (votre façon de travailler).

Qu’est-ce qu’un DAW ?

Un DAW (autrement appelé Digital Audio Workstation) est le logiciel qui vous permettra de globalement tout faire : enregistrer que ce soit de l’audio ou des événements informatiques en MIDI, éditer vos prises, mixer votre projet, le structurer, etc.
La plupart des DAWs sont pour le moins onéreux, mais il en existe tout de même des gratuits, qui sont parfaits pour débuter.

Si vous êtes sur Windows, je ne peux que recommander des DAWs comme Audacity (un éditeur audio très puissant, mais incompatible avec le MIDI qui permet de se servir d’instruments virtuels), Bandlab (très complet et simple d’utilisation tout en étant gratuit), ou Ableton Live Lite (la version gratuite et limitée d’un des DAW les plus répandus dans l’industrie, surtout électronique).

À gauche Audacity, à droite Garageband. On remarque que les deux interfaces sont très similaires.

Si en revanche vous êtes sur Mac, la question ne se pose même pas : vous disposez déjà d’un DAW nommé Garageband (à droite sur les captures d’écran ci-dessus), extrêmement versatile et regorgeant de fonctionnalités très avancées voir d’un niveau professionnel et qui est, à mon sens, la meilleure manière de commencer la MAO, car très intuitif et ergonomique.

Les DAW payants, comme Logic Pro, FL Studio, Ableton Live ou Pro Tools offrent des fonctionnalités généralement bien plus avancées pour les professionnels, mais il est possible et même recommandé de débuter sans.
En effet, même un logiciel gratuit demande déjà des semaines entières à maîtriser. Il est donc inutile de se plonger dans une interface encore plus intimidante, sans guide préalable.

Présentation de Logic Pro

Je vais à présent survoler l’interface d’un DAW (Logic Pro) afin de parler rapidement des fonctionnalités principales de ces derniers. J’ai choisi ce logiciel car c’est celui avec lequel je suis le plus familier, mais il faut savoir que la majorité des DAWs ont sensiblement les mêmes fonctionnalités, avec des interfaces qui tendent à se rapprocher.

Voici à quoi ressemble l’interface lorsque nous ouvrons une séance existante dans le logiciel. Ne vous inquiétez pas si cela peut paraître intimidant, je vais tout expliquer pas à pas.

• La majorité de l’espace est occupée par la timeline. C’est l’endroit où les régions d’instruments (souvent des mesures) vont apparaître et se jouer. On remarque à gauche les pistes des instruments et à droite la structure des régions.

• La première fenêtre que nous allons aborder est celle du Piano Roll. C’est l’éditeur MIDI qui va nous permettre d’utiliser des instruments virtuels, comme un piano par exemple. On peut y écrire des notes, les enregistrer et les éditer à volonté.

• Tout à gauche, il y a la bibliothèque native d’instruments virtuels. Elle est particulièrement fournie sur Logic Pro et Garageband, mais chaque DAW est unique et possède un grand nombre d’instruments natifs dès l’installation.

• À l’opposé de la fenêtre, à droite, on retrouve la bibliothèque de boucles audio et MIDI pré-enregistrées qui sont d’une grande utilité pour trouver des idées ou enrichir une composition existante.

• En bas peut également s’ouvrir le Mixer. Une grande fenêtre avec plein de boutons qui permettent de gérer les volumes, les panoramiques et effets de chaque piste, bus et master.
Chaque tranche correspond à une rangée d’instruments sur la timeline. On peut également accéder à ces tranches en cliquant sur une rangée.

• Enfin en haut on retrouve une barre d’outil, personnalisable et qui nous donne des informations sur le tempo du projet, sa tonalité, voir l’endroit où l’on se situe dans la timeline (la mesure exacte et le temps) ainsi que des contrôles.

Plugins

Les plugins sont de très loin les choses les plus utiles dans la MAO. Ce sont des applications qui s’ouvrent directement dans le logiciel et qui permettent d’y ajouter des fonctionnalités.

Les plugins ne sont pas indispensables, mais présentent des ressources très précieuses, que ce soit pour la composition ou pour le mix de votre projet.

Certains plugins sont gratuits et varient en qualité, allant de professionnels à inutiles, tandis que d’autres sont payants, mais cela ne veut pas dire qu’ils sont sans défauts. Ils se séparent en deux catégories principales, les instruments virtuels et les effets.

Les instruments virtuels

Les instruments virtuels sont tout simplement des instruments comme un synthétiseur, une batterie, un violon, etc… qui s’utilisent grâce au protocole MIDI, virtuellement donc.
Bien sûr un instrument virtuel ne remplacera jamais un vrai musicien, ni l’instrument en lui-même, car même si la technologie évolue rapidement, la différence est toujours notable.

Voici par exemple le plugin LABS, qui est une banque d’instruments externes à Logic de très grande qualité.

Les effets

Les effets permettent d’ajuster le son et de le moduler à notre guise. Il en existe un très grand nombre, mais les plus communs sont :

• La Reverb qui est tout simplement un effet temporel similaire à lorsqu’on parle dans une grande pièce vide, où notre voix se réverbère sur les parois.

• Le Delay aussi un effet temporel, où le son se répète après un certain temps et de plus en plus faible. En français, c’est de ça dont on parle quand on dit un écho.

• La Distorsion, comme ce qui se retrouve pour une guitare électrique et qui est très utile pour changer le caractère du son. Il existe plein de distorsions différentes, comme le fuzz, l’overdrive, ou encore le treble booster (littéralement l’amplification des aigus).

• La Compression est un effet dynamique, qui réduit les écarts de dynamique (en gros il sert à adoucir les sons forts et amplifier les sons faibles, pour garder un certain équilibre et mieux intégrer des instruments dans le mix).

• L’Égalisateur (appelé EQ), est un filtre qui sert à modifier les plages de fréquence d’un signal audio (par exemple amplifier les fréquences graves ou atténuer les fréquences aiguës).

Chacun est un outil qui sert à régler un problème ou apporter une texture différente au son et permet donc une manière de se rapprocher du son voulu. Il en existe bien évidemment bien plus que cela, tous avec leur but.
En général, ces plugins viennent nativement avec votre DAW, mais il est toujours possible de faire appel à des logiciels externes, s’ils vous conviennent mieux.

Voici par exemple un effet (appelé l’imager) qui permet de modifier la stéréo d’un signal audio, pour le rendre plus ou moins large, ce qui n’est pas possible avec les plugins natifs de Logic Pro.

Composition

Alors avoir des outils c’est chouette, mais il manque toujours le plus important : ce qu’on en fait. Qu’ils soient virtuels ou enregistrés, les instruments et ce qu’ils jouent restent la pierre angulaire de votre projet. Je vais donc décrire le processus de composition et le décomposer en plusieurs étapes :

• La première chose à faire c’est définir une tonalité, un tempo pour le projet (sa rapidité, en Battement Par Minute ou BPM), ainsi que sa signature rythmique (par exemple mon projet est en 5/4, mais la plupart sont en 4/4). Vous n’êtes pas obligés de connaître toute la théorie derrière ces choix, mais il est important de savoir que ces choix auront un impact plus tard.

• Ensuite, vous allez avoir besoin de mélodies. C’est là où l’aspect technologique de la MAO devient particulièrement intéressant, car vous n’avez pas forcément besoin de savoir jouer d’un instrument pour écrire votre mélodie dans le Piano Roll en MIDI. Vous pouvez simplement y écrire la mélodie que vous avez en tête, puis tenter de trouver une contre-mélodie et de continuer d’agrémenter de petits détails.

• Une fois que vous pensez avoir fini vos mélodies, vous devrez penser à poser des accords dessous. C’est une étape très importante, mais qui peut s’avérer compliquée si vous êtes complètement novice en théorie musicale. Trouver la bonne formule nécessite souvent des expérimentations, il est donc nécessaire d’y passer du temps.

• C’est à ce moment-là que vous allez devoir vous concentrer sur votre ligne de basse et votre rythmique. Ce sont des sujets assez complexes et il est nécessaire de connaître un peu de théorie si vous souhaitez explorer différents genres musicaux. Cependant, vous pouvez vous contenter du minimum : une ligne de basse qui suit la fondamentale de l’accord et un pattern de grosses caisses/caisses claires très simple.

Mixage

Une fois la composition terminée (même s’il est toujours possible d’y revenir plus tard si une idée vous vient entre temps), vous allez devoir mixer. Le mixage, c’est l’art d’équilibrer. Faire en sorte que tout sonne bien et soit cohérent. Il y a plusieurs étapes pour un mix réussi, qui seront toutes indispensables pour aboutir à un résultat qui soit agréable à l’oreille.

• Premièrement, le Mix statique. Cela consiste simplement à ajuster les niveaux de volume et les panoramiques (si votre piste est dans l’oreille gauche/droite, ou au milieu) et d’essayer de s’approcher le plus possible du résultat final seulement en s’occupant de ces deux paramètres.

Dans ce mixer : En haut le contrôle du pan, en dessous un contrôle du volume.

• C’est après que vous appliquerez vos effets à vos pistes individuelles. C’est indispensable pour créer de l’espace dans votre morceau, ne serait-ce qu’avec un EQ pour se débarrasser de fréquences non voulues, ou qui rentrent en conflit avec d’autres instruments. Une fois que toutes vos pistes seront mixées, votre projet devrait commencer à bien sonner.

• Enfin, vous pourrez appliquer des effets sur la totalité du projet, avec tous les instruments en même temps. L’idée ici est d’apporter encore plus de cohérence, en essayant de « gluer » de manière légère les éléments les uns aux autres pour qu’ils soient plus unis. Cela peut se faire à l’aide de compression, de reverb et d’un léger EQ sur cette même tranche.
À noter que la différence n’a pas à être flagrante : le but est d’être subtil afin de ne pas déséquilibrer le tout. C’est cette touche finale qui devrait permettre à votre projet de se rapprocher d’un résultat final.

Voici un exemple d’une chaîne d’effets sur un projet :

• D’abord, on a un EQ, qui vient légèrement accentuer les fréquences aiguës (le treble) et baisser les fréquences du milieu (les mids). Les basses étaient bien donc je ne les ai pas touchées.
• Ensuite, une reverb (Raum) très fine juste pour que les éléments soient moins « séparés » et une compression pour qu’il n’y ait pas trop de variations dans les dynamiques. À la suite de laquelle je remets un imager pour plus de largeur.
• Derrière, ce sont des plugins pour contrôler le volume (comme un limiteur) et je finis la chaîne avec un plugin de mastering et une légère distorsion pour caractériser le son un peu plus.

Structure

Une fois tout cela terminé, il ne vous reste plus qu’à construire la structure de votre morceau, mesure après mesure. Faites une introduction, des couplets, refrains, ponts, interludes, solos et des outros.

Amusez-vous avec les transitions et n’oubliez pas de laisser parler votre créativité : Si vous souhaitez changer de signature rythmique juste sur les couplets, c’est totalement possible. Si vous voulez laisser un grand blanc d’exactement 42 secondes en plein milieu du morceau, rien ne vous en empêche.

Voici un exemple d’à quoi pourrait ressembler la structure de votre morceau
(Intro/Couplet/Refrain/Couplet/Pont/Refrain/Outro)

À noter que ce processus créatif peut différer de personnes en personne. Je préfère construire la base de mon projet au début et construire la structure à la toute fin (quitte à rajouter des parties au dernier moment si je les estime nécessaires à la progression du morceau), tandis que d’autres préféreraient créer la structure en premier afin d’avoir une vision globale du projet et de composer par dessus.

La fin

Une fois que vous êtes satisfait de votre résultat final, il ne vous reste plus qu’à l’exporter, après ce qui s’appelle un bounce. Le format mp3 est très bien pour des fichiers de petite taille, mais vous perdrez un peu en qualité audio (étant compressé avec pertes), par rapport à un format comme wav, qui est bien plus adapté, mais aussi bien plus lourd.

La fenêtre de bounce dans Logic Pro. Il y a beaucoup de paramètres possibles, mais vous pouvez simplement laisser ceux par défaut.

Enfin, la MAO est un sujet très dense et complexe. Il est normal de s’y perdre et de ne pas tout savoir, c’est quelque chose qui s’apprend dans le temps, un peu comme un instrument de musique.
Mais j’espère que ce petit guide vous aura aidé à y voir plus clair et, à défaut de vous avoir convaincu de tenter, au minimum renseigné sur la façon dont sont produits l’écrasante majorité des morceaux de nos jours. Merci de votre lecture !

Art

Paysage : Le coucher de soleil en Python

  • par Pierre B.

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 !

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.

Le Coucher de SoleilTélécharger

Merci d’avoir lu cet article ! Nous espérons qu’il vous aura été utile !

Avatar de Pierre B.
Avatar de Robin P.