Author: Robin P.

Tutoriels

Comment monter un ordinateur ?

  • par Robin P.

Monter un ordinateur peut sembler compliqué, mais ce n’est pas si difficile lorsque l’on sait ce que l’on fait. Ce tutoriel possède deux grands objectifs. Le premier est de vous expliquer les spécificités techniques de chaque composant d’un ordinateur, afin de vous aider à choisir ceux qui correspondent le mieux à vos besoins. Le second objectif est de vous guider pas à pas pour apprendre à monter un ordinateur de A à Z.

Liste des composants ainsi que leur caractéristique

Le processeur : le processeur ou CPU (Central Processing Unit) est le cerveau de votre ordinateur. Il gère les échanges de données entre composants (mémoire RAM, disque dur, carte graphique). La fréquence des processeurs est en GHz. Concrètement, une fréquence de 2 GHz permet au processeur d’effectuer deux milliards d’opérations par seconde. Ce qui est un critère important dans le choix du processeur. De plus, La puissance de calcul et la vitesse de traitement sont multipliées par le nombre de cœurs sur la puce. Ainsi, plus un processeur a de cœurs, plus il sera puissant et multitâche. Évidemment, il vaut mieux avoir un processeur 2 GHz avec deux cœurs qu’un processeur 3 GHz avec un seul cœur.

La carte graphique : la carte graphique ou GPU (Graphics Processing Unit) est un périphérique graphique ou carte d’extension d’ordinateur dont le rôle est de produire une image affichable sur un écran. Pour bien choisir sa carte graphique, il faut regarder plusieurs caractéristiques. Sa fréquence, exprimée en MHz ou GHz, indique la vitesse à laquelle le GPU effectue ses calculs. Sa finesse de gravure plus elle est fine, plus elle est performante. Pensez à regarder la gamme de puces graphiques, les puces embarquées sur les GPU NVIDIA sont les GTX et RTX et Radeon RX pour AMD. Enfin, la VRAM embarquée dans la carte graphique plus il y en a, mieux c’est. ATTENTION, le prix monte très vite.

La carte mère : la carte mère est un circuit imprimé qui relie tous les composants entre eux. Pour choisir une carte, il faut regarder 3 points importants. Le 1er la compatibilité avec le processeur, il ne faudrait quand même pas choisir une carte mère INTEL avec un processeur AMD. 

2612058

  • Ne pas oublier que les processeurs possèdent des sockets (ce qui établit le contact entre la carte mère et le processeur) pour AMD ce sont AM4 et AM5 (le plus souvent). Pour Intel, ça marche en générations : 9ème, 10ème, 11ème, 12ème, 13ème et 14ème (pour savoir, il faut regarder les deux premiers chiffres du nom du processeur). Chaque génération correspond à un socket. Par exemple, pour un i9 13900K (13ème génération), le socket sera un LGA 1700.
  • Il faut aussi prendre la bonne taille de carte mère. Il existe trois principales tailles : ATX, micro-ATX et mini-ITX chacune correspond à une taille de boitier.
  • Enfin, choisir si l’on veut que notre carte mère possède des antennes ou non (pour capter le wifi et le Bluetooth).

Le SSD:  le SSD (Solid-State Drive) est une unité de stockage rapide. Il peut être trouvé sous différents formats.

  • Le 2.5 qui se connecte à l’aide d’un câble SATA.
  • Le M.2,lui se connecte directement à la carte mère il est plus intéressant que le format 2.5 au niveau du cable management, car il est moins  encombrant. Il possède aussi souvent une vitesse de lecture plus rapide que le 2.5 pour moins cher.
  • Le mSATA, ou mini-SATA, est une version plus petite du SSD SATA ordinaire. C’est un format compact, comme le M.2, sans être interchangeable.
  • L’U.2, pour finir, ressemble à un disque 2,5″ en un peu plus épais. Il utilise un connecteur différent et envoie ses données par le biais du PCIe. La technologie SSD U.2 est généralement réservée aux stations de travail, serveurs et applications d’entreprise haut de gamme qui nécessitent un stockage plus important.

Le HDD : le HDD (Hard Disk Drive) désigne le disque dur traditionnel à mémoire de masse magnétique. . Il est moins rapide qu’un SSD, mais il est souvent beaucoup moins cher. Mais je vous recommande quand même de privilégier le SSD au HDD.

La RAM : la RAM (Random Access Memory) est une banque de mémoire temporaire où votre ordinateur stocke les données qu’il doit retrouver rapidement. Elle est un composant essentiel pour votre ordinateur. La puissance de la RAM se remarque par trois grands critères : sa taille (8 Go, 16 Go, 32 Go, etc.), sa fréquence (3200 Mhz, 3600 Mhz, 600 Mhz, etc.) et enfin, la latence CAS (18, 32, etc.). Le CAS représente le nombre de « cycles d’horloge » nécessaires pour que le module accède à un ensemble spécifique de données dans l’une de ses colonnes et les mette à la disposition de la sortie. En gros, plus il est faible, plus la tâche sera accomplie rapidement.

Le refroidisseur de processeur : le refroidisseur de processeur sert, comme son nom l’indique, à refroidir le processeur. La chaleur générée par le processeur lui-même est distribuée au couvercle métallique du processeur, appelé diffuseur de chaleur intégré (Integrated Heat Spreader, IHS). La chaleur est ensuite transférée vers la plaque de base du refroidisseur du processeur. Cette chaleur est alors distribuée, soit par liquide, soit par le biais d’un tuyau thermique, vers un ventilateur, où elle est évacuée du refroidisseur, puis du PC. Il existe deux types de refroidisseurs le ventirad et le watercooling, chacun pour un usage bien spécifique. Le ventirad est moins cher et convient très bien aux petits et moyens processeurs, alors que le watercooling,lui, intervient sur les gros processeurs qui chauffent beaucoup.

L’alimentation : elle sert à alimenter chacun des composants de ton ordinateur. Pour calculer de quelle puissance d’alimentation vous avez besoin, je vous conseille de regarder ce site la https://fr.msi.com/power-supply-calculator. Les alimentations possèdent aussi une certification « 80 PLUS » suivie de BRONZE, ARGENT, GOLD, PLATINE et enfin TITANE elle représente la perte énergétique de l’alimentation. Par exemple, une alimentation BRONZE aura une plus grande perte énergétique qu’une alimentation ARGENT ainsi de suite. 

Le boitier : le boitier de l’ordinateur doit correspondre à la taille de la carte mère ATX, micro-ATX, etc. La carte graphique doit pouvoir rentrer dans l’ordinateur, car ce serait dommage de lâcher 800 euros dans une carte graphique pour qu’elle ne rentre pas. Il faut bien lire toutes les lignes de la fiche technique pour éviter tout problème. Il faudra peut-être penser à acheter des ventilos s’il n’y en a pas inclus avec le boitier, faites attention.

Informations complémentaire

Le Bottleneck ou goulot d’étranglement fait référence à un composant limitant le potentiel d’un autre élément matériel en raison des différences de capacité maximale des deux composants. Pour connaitre le goulot d’étranglement entre votre processeur et votre carte graphique, allez sur ce site https://pc-builds.com/fr/bottleneck-calculator/ mettez votre processeur, votre carte graphique et votre résolution d’écran, et cochez la case « Tâches intensives du GPU » si vous faites un ordinateur principalement pour jouer sur votre ordinateur. Un bon goulot d’étranglement est <5%.

Montage de l’ordinateur

Liste du matériel à avoir pour le montage :

  • Plusieurs tournevis 
  • Des rislans (il y en a souvent fournis avec la carte mère, mais je vous conseille quand même d’en avoir).
  • une pièce bien illuminée

La mise en place de la carte mère

  • Commencez par déballer la carte mère ainsi que les câbles fournis avec et placez-les là sur un morceau de polystyrène présent dans la boite de la carte mère ou du GPU.
  • Pour installer le processeur, vous devez tout d’abord lever la sorte de petit levier et poser délicatement le processeur sur le socket (!!! ATTENTION pour les processeurs AM4, ne tordez pas les pins au dos du processeur en le plaçant, soyez délicat !!!). Puis redescendez délicatement le levier, mais avec une certaine pression.
  • Pour la RAM, installez-la à droite du processeur sur les sortes de rangées. Si vous avez deux barrettes, déclipsez les rangées 2 et 4 pour faire du DUAL CHANNEL. Placez ensuite dans le bon sens (oui, il y a un sens) les barrettes de RAM. Avec un peu de force, elles vont se clipser toutes seules. ÉVITEZ DE TOUCHER LA PARTIE DORÉE DE LA RAM !!!
  • Le SSD M.2 se connecte à la carte mère en dessous du processeur, au-dessus de la carte graphique. On peut dévisser un petit cache pour insérer le SSD dans le port M.2 en alignant les encoches. Puis revisser le cache par-dessus.
  • Maintenant, concentrons nous sur le ventirad. Pour cela, regardez les instructions données par le manuel de votre ventirad en fonction du processeur, n’oubliez pas d’appliquer la pâte thermique sur le processeur, puis branchez le ventilo de votre ventirad sur les pins « CPU FAN ». Vous pouvez maintenant l’installer dans votre boitier. Faites attention à bien l’aligner avec l’emplacement des vis.
     

La mise en place des autres composants dans le boitier

  • L’alimentation se place tout en bas à gauche du boitier. Pour cela, ouvrez la plaque arrière de celui-ci et installez l’alimentation en bas à droite quand vous êtes face au dos du boitier avec le ventilateur de l’alimentation vers le bas. Préparez bien les câbles dont vous aurez besoin pour alimenter votre MACHINE DE GUERRE, puis vissez-la correctement.
  • La carte graphique se branche sur la carte mère. Pour cela, dévissez les supports arrière du boîtier PCI qui s’alignent avec l’emplacement PCI que vous utiliserez. Retirez la protection qui recouvre la bande PCI du GPU. Puis l’insérer dans la fente jusqu’à entendre le clic de fixation, puis la visser au boitier grâce au support.
  • Les HDD se branchent à la carte mère avec un câble SATA. Certains boitiers possèdent un petit tiroir où les HDD peuvent être rangés.
  • Les SSD 2.5 se branchent à la carte mère avec un câble SATA et peuvent souvent être fixés magnétiquement à l’arrière du boitier ou dans un emplacement dédié.

Les branchements

L’alimentation est reliée à :

  • La carte mère :
  • La carte graphique :
  • Au processeur :
  • Enfin, à l’HDD et au SSD :

Les ventilos sont branchés aux pins avec écrit « FAN »

Pour tous les branchements liés au boitier, comme le bouton de démarrage ou un port USB-C, référez-vous au manuel du boitier.

 

Conseille

Si vous ne comprenez pas une partie, vous trouverez énormément de vidéos en ligne sur comment bien monter un ordinateur. De plus, lisez bien les manuels des composants, ils possèdent souvent la réponse à toutes vos questions. Monter un ordinateur demande juste de la patience, rien n’est bien compliqué.

 

Art

Paysage : Le coucher de soleil en Python

  • par Robin P.

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.