Author: Lisa V.

Art

Paysage : un coucher de soleil

  • par

Les couchers de soleils vous fascinent ? Vous êtes ici au bon endroit pour apprendre à créer des levers et couchers de soleil de votre choix sans devoir attendre le crépuscule. Je vous explique en détail mon script qui permet de générer une image avec le module turtle en python.

Les prémices du projet

Dans un premier temps, j’ai longtemps réfléchi à ce que je pouvais faire pour le projet libre de cette fin d’année. Je me suis décidée à refaire une image générée par le module turtle en python. Effectivement, notre tout premier projet de l’année était le même, néanmoins j’avais tout de suite commencé très fort en faisant des fractales. Certains vous diront que cela est facile, mais mon niveau de début d’année ne me permettait pas de tout comprendre. Ce qui m’a frustré. Je me suis donc décidée à refaire une image avec mon niveau actuel (qui est encore débutant !) pour pouvoir gérer la conception de A à Z.

Par conséquent, le script et l’image peuvent vous paraître assez simple. Cependant, j’ai souhaité m’inspirer du projet https://nsi.xyz/art/urbanisme-la-skyline-de-new-york/ qui se rapproche du flat design (ils l’expliquent très bien dans leur article). Le rendu final est donc très épuré et très simple.

Le code

Pour concevoir cette image, j’ai procédé par étapes pour créer le code. En découpant mon image, en plusieurs parties.

Le fond

Tout d’abord, j’ai codé le fond c’est-à-dire le coucher de soleil. L’espace utilisé est découpé en morceau rectangulaire. Puis pour chaque rectangle est associé une couleur. Je définis donc en premier mes neuf couleurs. Ensuite, j’utilise une boucle for, qui prend à chaque itération de la boucle la couleur suivante contenu dans la liste couleur.

def coucherdesoleil():
    couleur = ["#FFBA08",
               "#FAA307",
               "#F48C06",
               "#E85D04",
               "#DC2F02",
               "#D00000",
               "#9D0208",
               "#6A040F",
               "#370617"]
    penup()
    goto(640,-300)
    setheading(180)
    pendown()
    
    for fond in couleur: # ChatGPT m'a aidé sur cette ligne et la ligne suivante
        color(fond)
        begin_fill()
        forward(1280)
        right(90)
        forward(74)
        right(90)
        forward(1280)
        end_fill()
        
        left(180)

Le résultat :

Les étoiles

Puis, je crée une fonction qui permet de dessiner des étoiles. Elle prend en paramètre la longueur des branches, et l’emplacement de l’étoile, tout en définissant sa couleur.

def etoile(longueur, x, y):
    goto(x,y)
    pencolor("#DF7B0A")
    pendown()
       
    left(50)
    for i in range(5):
        forward(longueur)
        right(144)
    
    penup()

Je souhaitais que les étoiles se situent seulement en haut du ciel, tout en se positionnant de façon aléatoire, et de taille aléatoire. Ainsi par la boucle for , dix étoiles sont créées avec des paramètres précis (taille et position) mais de façon aléatoires.

for i in range(10):
    etoile(randint(5,15), randint(-630,630), randint(293, 350))

Le résultat :

Le soleil

Ensuite, le script exécute la fonction créant le soleil. Il se positionne à des coordonnées précises, je positionne le curseur en direction du haut de l’image : setheading(90), puis j’utilise la fonction prédéfinie du cercle, en indiquant la taille du rayon et si je souhaite un demi-cercle ou un cercle.

def soleil():
    goto(-115, -285)
    fillcolor("#FFC93E")
    begin_fill()
    setheading(90)
    circle(70, 180)
    end_fill()

Le résultat :

Les montagnes

Pour cette fonction, je me suis inspirée voir même j’ai repris la boucle créant l’ondulation des montagnes de mon ancien projet https://nsi.xyz/art/jardins-foret-enneigee/. Afin de créer une montagne, il faut lui donner comme paramètres d’entrée sa position initiale et finale (pour qu’ensuite elle puisse être remplie), la couleur, la direction, l’angle et la longueur des vagues.

De plus, pour varier la taille des montagnes, j’ai utilisé un test conditionnel afin de modifier l’inclinaison en fonction de sa position initiale.

Enfin, la boucle for permet de créer une vague, qui se répètent trois fois, formant une ondulation.

def rocher(x1, y1, x2, y2, couleur, direction, angle, vague1, vague2):
    fillcolor(couleur)
    pencolor(couleur)
    goto(x1,y1)
    if direction == 0:
        setheading(0)
        right(angle)
    else:
        setheading(direction)
        left(angle)   
    
    begin_fill()

    pendown()
    for i in range (3): # boucle repris de mon ancien projet https://nsi.xyz/art/jardins-foret-enneigee/
        for i in range (5):
            forward(vague1)
            right(2)
        for i in range (5):
            forward(vague2)
            left(2)
    
    goto(x2,y2)
    
    penup()
    end_fill()

Le résultat final

Les problèmes rencontrés et leurs solutions

Le premier problème était que les montagnes ne s’arrêtaient pas toutes à la même ligne, il y avait donc des débordements en dehors du cadre. Ma solution a été de créer une ligne blanche repassant sur ces débordements. Je pense qu’il y avait sûrement une solution ou un bout de code permettant de stopper les boucles quand elles arrivaient à un certain endroit, mais j’ai préféré utiliser cette méthode.

Le deuxième problème a été l’emplacement des étoiles. Effectivement, au début vingt étoiles étaient créées avec des emplacements aléatoires, par conséquent il y avait des superpositions. J’ai donc décidé de réduire le nombre, afin que les étoiles aient moins de chance d’obtenir la même position.

Le troisième problème n’en est pas vraiment un, mais cela était plutôt un souhait que je n’ai pas réussi à effectuer. En effet, je souhaitais faire un beau dégradé pour le coucher de soleil. J’en avais vu un sur cet article https://nsi.xyz/art/perspective-un-paysage-synthwave/ j’ai longtemps essayé de comprendre la fonction et j’ai même demandé à ChatGPT, mais sans succès. J’ai donc décidé de ne pas copier coller un code que je ne comprenais pas et j’ai laissé le coucher de soleil actuel.

Mes sources

J’ai principalement codé avec mes connaissances, les cours de NSI et les anciens projets disponibles sur le site https://nsi.xyz/. Toutefois, j’ai eu besoin de faire des recherches et j’ai utilisé ChatGPT à plusieurs reprises pour qu’il me montre mon erreur lorsque je ne comprenais pas le message d’erreur ou quand je ne comprenais pas tout à fait les explications que je trouvais sur internet.

Conclusion

En conclusion, je suis très fière de mon image. Même si son codage est effectué avec les base de la programmation et peut paraître facile. J’ai pris plaisir à programmer, comprendre, corriger toute seule mes erreurs, afin de concevoir une image propre à mes connaissances et à mes envies.

Télécharger le .py

Si vous souhaitez générer l’image et l’utiliser comme fond d’écran n’hésitez pas à télécharger le fichier ci-dessous.

coucher_de_soleilTélécharger
Tutoriels

Obsidian : le logiciel de prise de note

  • par

Obsidian est un logiciel gratuit qui vous permettra de ne plus jamais apprendre ou lire quelque chose inutilement. En effet, il vous permettra de prendre des notes et de les lier entre elles de façon très intuitive. Je vous propose ici un petit aperçu de ce logiciel de prise de note en vous conseillant les différents paramètres et modules à activer, afin de débuter en toute sérénité et rapidité. Vous pourrez ainsi immédiatement commencer son utilisation et devenir un pro en prise de note.

Installation du logiciel

Tout d’abord, rendez vous sur le site https://obsidian.md/. Téléchargez Obsidian soit en appuyant sur le bouton violet s’il détecte votre version ou bien en choisissant le lien qui correspond à votre plateforme.

Lors de l’ouverture du logiciel, la fenêtre ci-dessous s’ouvre.

Je vous conseille de créer un nouveau coffre. En effet, un coffre (« vault » en anglais) correspond à un dossier où sont stockées toutes les notes sur Obsidian.

Vous pouvez ensuite choisir le nom du coffre et son emplacement sur votre ordinateur.

Si vous souhaitez approfondir votre connaissance du logiciel, vous pouvez aller sur le coffre « Aide » qui se situe en bas à gauche de la fenêtre (caractérisé par un point d’interrogation dans un cercle). Cependant, il n’existe pas en français, mais vous pouvez le lire en anglais ou dans les autres langues proposées.

Markdowns essentiels

Le markdown est un langage de balisage léger qui permet d’offrir une syntaxe facile à lire et à écrire.

  • Le niveau de titre est spécifié par # (Il existe six niveaux de titres différents. Plus il y a d’hashtags, plus le niveau de titre est élevé et petit.).
  • Le mot en gras est entouré de deux étoiles de chaque coté : ** **
  • Le mot en italique est entouré d’une étoile de chaque coté : * *
  • La liste à puce est spécifiée par des tirets.
Notation
Présentation
  • La liste numérotée est spécifiée par des 1. au début de chaque élément.
Notation
Présentation
  • Créer un lien s’effectue avec des doubles crochets : [[]] . Sélectionnez ensuite la note vers laquelle vous souhaitez créer un lien.

Pour aller vers cette note faite Command + clic gauche.

Pour connaitre tous les markdowns disponibles, vous pouvez vous rendre sur le coffre « Aide », puis dans « how to » et « format your notes ». C’est très intuitif et même si vous ne comprenez pas l’anglais vous pouvez tout de même réussir à les utiliser.

Interface

Nous allons maintenant nous intéresser à l’interface du logiciel.

Tout d’abord, nous allons passer en revue les différents paramètres qui selon moi sont utiles d’activer.

Les paramètres qui sont déjà activés peuvent rester actifs. Puis dans l’onglet Editeur, activez le pliage de l’en-tête et le pliage de l’indentation. Cela permet de replier le contenu dans l’en-tête, afin d’avoir une vision plus clair de la note.

Ensuite, dans l’onglet Fichiers & Liens, je vous conseille que les « fichiers supprimés » soit déplacés vers la corbeille d’Obsidian et non dans la corbeille du système. Par conséquent, si vous souhaitez retrouver un fichier supprimé, même si la corbeille a été vidée, vous le retrouverez.

Activez aussi le fait de toujours mettre à jour les liens internes. Ainsi si vous modifiez le nom d’une note, le lien vers elle sera aussi modifié.

De plus, dans l’onglet Apparence vous avez accès à une bibliothèque de thèmes, qui ont été créés par la communauté. Vous pouvez choisir celui qui vous plaît et l’utiliser comme interface de votre Obsidian. Pour cela cliquez sur le thème choisi, puis appuyez sur « utiliser » et le tour est joué !

Par ailleurs, l’onglet Modules principaux regroupe des petits logiciels qui sont rajoutés à Obsidian et lui donnent des fonction en plus. Je vous conseille d’en activer trois en plus de ceux déjà activés, afin de rendre votre utilisation plus facile.

Mes modules préférés

En outre, il existe de nombreux modules, en plus de ceux déjà téléchargés par défaut, qui ont été créés par des membres de la communauté. Je vous en propose ici quatre qui améliorent l’utilisation d’Obsidian. Mais vous pouvez en télécharger autant que vous le souhaitez.

Dans un premier temps, rentrez dans les paramètres, puis dans modules complémentaires. Ensuite, cliquez sur « Parcourir » et recherchez vos modules pour pouvoir les télécharger par la suite.

  • Module « Advanced Slides »

Ce module est très intéressant lorsque vous souhaitez faire une présentation avec vos notes actuelles. Il suffit d’espacer les différentes parties de la note avec trois tirets pour créer des diaporamas. Cela vous permet ainsi de présenter votre travail de façon claire et concise.

  • Module « Calendar »

Ce module est un bon outil pour afficher toutes les notes quotidiennes et s’y retrouver.

Il suffit d’aller sur le symbole en haut à droite (comme montré sur l’image), afin d’identifier les jours et le nombre de notes écrites.

  • Module « Kanban »

Cela permet de créer des listes qui classent les notes en fonction de thèmes, ou par exemple de révisions à effectuer.

Pour créer un kanban :

  • taper command + P
  • sélectionnez « Kanban: create a new board« 
  • Choisissez ensuite un titre à votre liste et appuyez sur « add list« .
  • Vous pouvez ensuite sélectionner une note et la glisser dans cette liste.
  • Module « Récupération de fichiers »

Ce module complémentaire est très utile, car il vous permet de retrouver des modifications faites sur votre note, mais qui ne sont plus récupérable par la touche command + Z.

  • Allez dans les paramètres (en bas à gauche), puis séléctionnez « récupération de fichiers« .
  • Appuyez sur Ouvrir et sélectionnez la note souhaitée.
  • Choisissez le texte recherché, puis Copier dans le presse-papier
  • Il vous suffira ensuite de le coller où vous le souhaitez.

Raccourcis clavier

Je vous rassure, il ne faut pas tous les apprendre. Avec la commande (command+P) vous pouvez avoir accès à tous les raccourcis en un claquement de doigts.

Néanmoins, voici les plus importants et les plus utiles à connaitre :

  • CMD (= command) + O : a comme conséquence de vous proposer de basculer vers une autre note ou bien d’en créer une autre ( shift + entrée)
  • CMD OPT -> : nous permet de revenir en arrière ou d’aller en avant comme sur un navigateur avec les deux flèches.
  • CMD + N : a pour effet de créer une nouvelle note.
  • CMD + Shift + F : a comme résultat de rechercher votre note dans la barre de recherche dans Obsidian, par conséquent dans toute votre base de données.
  • CMD + G : montre la vue graphique, cela n’est pas très utile, mais la représentation est sympa. cela vous permettra d’impressionner votre entourage !

Conclusion

Si l’application « Note » suffit largement pour des personnes prenant des notes simples, des utilisateurs avancés seront vites limités et se tourneront vers des logiciels de prise de note expert comme Obsidian qui promeut la créativité et l’émergence de nouvelles idées .

Art

Jardins : Forêt enneigée

Ce script génère une image aléatoire de forêt enneigée en utilisant deux fractales très connues : l’Arbre de Pythagore et le Flocon de Koch.

Les fractales

Le Flocon de Koch

Le Flocon de Koch utilise une courbe fractale. Une courbe fractale est un dessin composé de segment dont la forme de base va être reproduite à l’infini.

Dans le cas de la courbe de Koch, sur chaque segment, un triangle va être dessiné, et pour chaque niveau, on va rajouter un triangle sur les nouveaux segments.

Pour créer cette courbe, on va utilisé le principe de récursivité, c’est à dire qu’on va appeler dans une fonction python la fonction elle-même.

def cote(longueur,niveau):
    if niveau==0:
        forward(longueur)
    else:
        cote(longueur/3,niveau-1)
        left(60)
        cote(longueur/3,niveau-1)
        right(120)
        cote(longueur/3,niveau-1)
        left(60)
        cote(longueur/3,niveau-1)

On exécute la fonction cotée en définissant la longueur et le niveau de répétition souhaité. Ligne 2, on vérifie que le niveau est égal à 0. S’il ne l’est pas, ligne 5, on rappelle la fonction et cette fois-ci la longueur est divisée par 3 et on enlève 1 au niveau. Ainsi, on répète tant que le niveau n’est pas égal à 0, et quand le niveau est égale à 0, on avance de « longueur ».

En répétant cela plusieurs fois, on obtient la courbe de Koch.

Pour obtenir un flocon, on répète cette courbe trois fois.

def flocon(longueur,niveau,x,y):
    width(1)
    penup()
    goto(x,y)
    pendown()
    for i in range(3):
        cote(longueur,niveau)
        right(120)

Ce code provient de https://www.numworks.com/fr/professeurs/activites-pedagogiques/premiere/flocon/

L’arbre de Pythagore

L’arbre de Pythagore fonctionne de la même manière : la fonction s’appelle elle-même.

def arbre(n,longueur,w,r1,g1,b1,r2,g2,b2):
  if n==0 :
    pencolor(r1,g1,b1)
    forward(longueur)
    backward(longueur)
    pencolor(r2,g2,b2)
  else:
    width(w) 
    forward(longueur/3)
    left(50) 
    arbre(n-1,longueur*2/3,w/1.2,r1,g1,b1,r2,g2,b2)
    right(2*50)
    arbre(n-1,longueur*2/3,w/1.2,r1,g1,b1,r2,g2,b2)
    left(50)
    backward(longueur/3)

Cette fonction prend plusieurs paramètres :

  • le niveau n de répétition
  • la longueur du tronc
  • la largeur w : afin que les arbres éloignés soient plus fins que les arbres au premier plan, on définit la largeur. Plutôt que d’utiliser w-1 (sinon après un certain niveau de répétition la valeur deviendrait négative), on utilise w/1.2 ce qui permet de réduire la valeur sans changer son signe.
  • r1,g1,b1 : qui définissent en RGB la couleur des feuilles.
  • r2,g2,b2 : qui définissent en RGB la couleur du tronc.

Ce code provient de https://my.numworks.com/python/cent20/arbre

Le fond

L’exécution du fond et des montagnes

A chaque exécution le fond va être d’une couleur aléatoire.

color(randint(10,250),255,255)
begin_fill()
goto(-640,700)
pendown()
goto(640,700)
goto(640,-700)
goto(-640,-700)
end_fill()

A chaque fois que nous exécutons le script, le résultat est unique, les montagnes ayant une forme définie auront une couleur aléatoire.

Script d’une des montagnes :

for i in range (10):
    for i in range (5):
        forward(20)
        right(2)
    for i in range (5):
        forward(10)
        left(2)

Cette boucle crée des fragments de cercles collés, qui forment une ondulation.

Les trois montagnes donnent cette image, avec des couleurs uniques à chaque fois.

L’exécution des arbres

On dessine 7 arbres en tout : 2 sur la montagne du fond, 2 sur la montagne du milieu et trois sur la montagne du devant. Chaque arbre a un secteur donné sur sa montagne et il est dessiné dans ce secteur, de façon unique à chaque fois.

Les arbres sur la montagne la plus éloignée sont plus petits, plus fins et plus sombres, cependant chaque arbre est d’une couleur, d’une taille et d’une largeur différentes à chaque exécution.

Voici par exemple l’exécution d’un arbre sur la montagne du fond

penup()
goto(randint(-550,-450),randint(120,160))
pendown()
setheading(90)
color(75,randint(40,50),randint(0,20))
arbre(9,randint(50,90),randint(4,7),randint(130,180),randint(160,180),180,75,randint(40,50),randint(0,20))

L’exécution des flocons

Ensuite on exécute les flocons:

for i in range (randint(30,45)):
    setheading(randint(0,360))
    color(randint(0, 220),randint(110, 240),255)
    begin_fill()
    flocon(randint(20,50),randint(3,5),randint(-639,639),randint(-310,310))
    end_fill()

A chaque exécution, le nombre de flocons est différent. Chaque flocon est orienté différemment , à une couleur, une taille, un niveau de répétition, et un emplacement différent.

L’image finale

Télécharger le .py

Si vous voulez l’essayer, vous trouverez le script ci-dessous, cependant faites attention, chaque arbre prend relativement longtemps à s’exécuter, ajouté aux flocons, le script prend environ 1h30 à s’exécuter.

forêt enneigéeTélécharger