Étiquette : image

Tutoriels

Trouver des images libres de droit

Une image vaut 42 mots ! Pour rendre un article ou un site agréable, il ne faut pas négliger son illustration. Réaliser soi-même des belles photos nécessite des compétences poussées en photographie, aussi il est conseillé d’utiliser des photos libres de droits, ce tutoriel vous présente où trouver ce telles images.

Pourquoi utiliser des images libres de droit ?

Il y a plusieurs raisons d’utiliser des images libres de droit:

  1. Éviter les poursuites en justice: en utilisant des images libres de droit, vous évitez les risques de poursuites en justice pour infraction aux droits d’auteur.
  2. Économiser de l’argent: les images libres de droit peuvent être utilisées gratuitement ou à un coût réduit, ce qui peut aider à économiser de l’argent par rapport à l’achat d’images avec des droits d’utilisation limités ou exclusifs.
  3. Plus de flexibilité: les images libres de droit peuvent être utilisées pour diverses fins commerciales et personnelles sans restrictions, ce qui offre plus de flexibilité dans leur utilisation.
  4. Contribuer à la communauté: en utilisant des images libres de droit, vous pouvez soutenir les créateurs en les encourageant à partager leur travail avec la communauté.

Les images sur google sont-elles libres de droit ?

Non, la plupart des images trouvées sur Google ne sont pas libres de droit. La plupart des images en ligne sont protégées par des droits d’auteur, ce qui signifie qu’il est nécessaire d’obtenir l’autorisation du propriétaire des droits d’auteur pour les utiliser. Cependant, Google peut inclure des images avec des licences libres de droit ou des licences Creative Commons, qui permettent une utilisation limitée ou gratuite sous certaines conditions. Il est important de vérifier la licence associée à chaque image avant de l’utiliser.

Comment vérifier qu’une image est libre de droit ?

Il existe plusieurs façons de vérifier si une image est libre de droit :

  1. Recherchez des images avec des licences libres de droit: il existe plusieurs sites web, tels que Pexels, Unsplash, et Pixabay, qui proposent des images avec des licences libres de droit.
  2. Vérifiez les licences Creative Commons: certaines images peuvent être publiées sous une licence Creative Commons, qui permet une utilisation limitée sous certaines conditions. Vous pouvez vérifier la licence associée à une image en utilisant un moteur de recherche d’images avec filtrage par licence.
  3. Contactez le propriétaire des droits d’auteur: si vous ne parvenez pas à trouver une licence associée à une image, vous pouvez contacter le propriétaire des droits d’auteur pour obtenir une autorisation d’utilisation.

Il est important de toujours respecter les droits d’auteur et de ne pas utiliser d’images sans autorisation, car cela peut entraîner des poursuites en justice et des frais importants.

Et les images sur wikipédia / wikimedia ?

Les images publiées sur Wikipedia et Wikimedia sont généralement soumises à des licences libres de droit ou à des licences Creative Commons. Cela signifie que vous pouvez utiliser ces images pour un usage personnel et commercial, mais vous devez respecter les conditions spécifiées dans la licence associée à chaque image.

Il est important de vérifier la licence associée à chaque image avant de l’utiliser, car certaines images peuvent être soumises à des restrictions d’utilisation. Par exemple, certaines licences peuvent exiger que vous attribuiez l’auteur de l’image, ou que vous utilisiez l’image uniquement pour des fins non commerciales.

Il est également recommandé de vérifier les sources de l’image et de s’assurer qu’elle n’est pas protégée par un droit d’auteur plus restrictif.

Attribuer l’auteur de l’image ? Quésaco ?

publique de l’auteur d’une image. Cela peut inclure l’ajout du nom de l’auteur ou du créateur de l’image, ainsi que d’autres informations telles que la source ou la date de création.

L’attribution est souvent requise pour les images publiées sous certaines licences libres de droit ou Creative Commons. Cela permet de respecter les droits des auteurs en reconnaissant leur travail et leur contribution à la communauté. Il est important de suivre les instructions d’attribution spécifiées dans la licence associée à chaque image pour éviter tout problème de droit d’auteur.

En général, l’attribution est une pratique courante pour les images en ligne et peut aider à promouvoir le travail d’artistes et de créateurs tout en fournissant des informations utiles pour les utilisateurs.

Pour nos élèves en spécialité NSI :

  • Pour vos articles sur nsi.xyz, vous devez indiquer les sources des images à la fin de l’article.
  • Pour vos sites web, vous devez indiquer les sources des images dans le compte rendu.

Une photo que j’ai prise est-elle libre de droit ?

Oui, généralement, si vous prenez une photo, vous en êtes le propriétaire et avez le contrôle exclusif sur les droits d’utilisation de cette photo. Cela signifie que vous pouvez décider de la publier ou de la distribuer, de la vendre ou de la protéger par des droits d’auteur, ou même de la céder à des tiers.

En tant que propriétaire de cette photo, vous pouvez l’utiliser librement pour illustrer un article ou un site web, et ce sans nécessairement renoncer à vos droits ultérieurs.

Cependant, il est important de tenir compte des lois sur les droits d’auteur et la vie privée dans votre pays, car certaines restrictions peuvent s’appliquer à l’utilisation de photos de personnes, de bâtiments ou de marques déposées. Il est donc toujours bon de vérifier les lois en vigueur et de respecter les droits des autres avant de publier ou d’utiliser une photo.

Une image trouvée sur une banque d’image est-elle libre de droit ?

Non, pas nécessairement. Les images disponibles sur les banques d’images peuvent être soumises à des licences différentes, allant des licences libres de droit à des licences payantes. Il est donc important de vérifier la licence associée à chaque image avant de l’utiliser, afin de savoir si vous avez le droit de l’utiliser pour votre projet ou votre entreprise.

Certaines banques d’images proposent des images gratuites avec des licences libres de droit, tandis que d’autres nécessitent un paiement pour utiliser une image. Il est donc important de bien comprendre les conditions d’utilisation associées à chaque image avant de les télécharger ou de les utiliser.

Certaines banques d’images libre proposent aussi des liens vers des images qui ne le sont pas.

Il est plus que conseillé d’utiliser ublock origin avant de se rendre dans ces banques d’images.

En général, il est préférable d’utiliser des images avec des licences claires et libres de droit pour éviter tout problème de droit d’auteur. Si vous avez des doutes, il est toujours bon de consulter un avocat spécialisé dans les droits d’auteur pour obtenir des conseils juridiques.

Les images avec un filigrame sont-elles libre de droit ?

Un filigrame ou une marque d’eau est généralement utilisé pour indiquer que l’image appartient à un propriétaire particulier ou pour dissuader les utilisateurs de voler ou de partager l’image sans autorisation.

Et si je trouve cette image qui est payante sans le filigrame sur Google ?

Si vous trouvez une image payante sur Google sans filigramme, vous ne devriez pas l’utiliser sans l’autorisation du propriétaire de l’image. L’utilisation non autorisée d’une image protégée par des droits d’auteur peut entraîner des poursuites judiciaires et des coûts importants pour violation de droits d’auteur.

Banque d’images libres de droit

Attention, vous devrez toujours vérifier la licence de l’image. La presence d’un site dans cette liste n’offre aucune garantie légale.

Nom du siteDescriptifAdresse du site
PexelsBanque d’images gratuite avec des milliers d’images haute résolutionhttps://www.pexels.com/
UnsplashBanque d’images gratuite avec une grande sélection de photos créativeshttps://unsplash.com/
PixabayBanque d’images gratuite avec des milliers d’images, de photos et de vecteurshttps://pixabay.com/
FlickrPlateforme communautaire avec des millions de photos libres de droithttps://www.flickr.com/
StockSnapBanque d’images gratuite avec des photos haute résolution téléchargées régulièrementhttps://stocksnap.io/
PicJumboBanque d’images gratuite avec des photos de qualité pour les projets commerciaux et personnelshttps://picjumbo.com/

Attention au poids des images

Il est préférable de se limiter à une résolution proche du full HD pour de la publication sur le web. (image est composée de 1920 pixels horizontaux et 1080 pixels verticaux)

A propos des images générées par des IA

Les images générées par des IA sont souvent considérées comme étant sans droit d’auteur, car elles sont considérées comme des créations de logiciels, plutôt que des créations humaines. Cependant, cela dépend des lois et des réglementations en vigueur dans chaque pays.

Dans certains cas, les images générées par des IA peuvent être considérées comme des œuvres dérivées d’images originales et peuvent donc être soumises à des restrictions en matière de droits d’auteur. Il est important de consulter les conditions d’utilisation de chaque logiciel d’IA pour savoir s’il est possible d’utiliser les images générées à des fins commerciales ou personnelles.

En général, il est préférable de faire preuve de prudence et de ne pas utiliser les images générées par des IA sans autorisation, sauf si vous êtes sûr de ne pas violer les droits d’auteur. Il est toujours préférable de créer ou de trouver des images libres de droit pour vous assurer que vous pouvez les utiliser en toute légalité et en toute sécurité.

Pour les élèves en spécialité NSI, les images illustrant les vignettes des articles de cette page https://nsi.xyz/category/decouvrir/ ont été générées par une IA, en voici un exemple.

midjourney : logo web, programmer, coder, langage, numérique, informatique, noir & blanc, violet, modern et fluide –ar 3:2 –
Upscaled by @cent20 (fast)

La controverse sur les droits d’auteurs associés à ces images ne fait que commencer, mais jusqu’à ce qu’elle soit tranchée vous pouvez utiliser des IA pour générer des images à condition de ne pas violer les droits d’auteur ni le droit des marques. Attention, vous devez avoir généré l’image vous même, et ne pas réutiliser une image générée par un tiers.

Article écrit avec l’aide de chatGPT jan 20 version. 2 images ont été générées par midjourney l’autre est une capture d’écran de pixabay. Aucun droit d’auteur n’a été à priori violé dans cet article.

Tutoriels

Comment utiliser et comprendre le fonctionnement de l’intelligence artificiel…

Dans ce tutoriel je vais vous expliquer clairement le mode de fonctionnement de l’une des intelligences artificielle les plus développer actuellement présente dans le milieu informatique, qui vous permettra de devenir un véritable artiste peintre en quelques minutes.

Cette innovation est menée par l’entreprise Nvidia qui est entre autres reconnue mondialement pour ces cartes graphiques. En effet le jeudi 24 juin 2021 l’entreprise publie officiellement la bêta public de son intelligence artificielle. Celle-ci est de nos jours encore en constantes évolutions, c’est-à-dire que l’on a accès à seulement une petite partie des fonctionnalités de l’application définitives. Elle a donc pour but de « vulgariser » afin de rendre accessible au monde entier le talent d’artiste peintre. Cependant elle peut aussi convenir aux artistes afin de les aider à imaginer une première version de leur travail.

La création de l’intelligence artificielle

Cette avancée majeure dans le monde des IA est en partie grâce aux développeurs de chez Nvidia qui ont fait analyser des millions d’images de paysages existant de notre monde, afin qu’elle puisse en créer une de toutes pièces, tout en gardant une vision vraisemblable.

Conditions d’utilisation :

Cependant cette technologie n’est disponible seulement sous le système d’exploitation Windows 10. De plus sa demande en vitesse de calcul étant très élevé elle n’est disponible que sous certaines conditions :

  • Une unité de traitement graphique (GPU) tels que la NVIDIA GeForce RTX, ou NVIDIA RTX, et TITAN RTX.
  • Un disque dur en SSD (un disque dur utilisant des éléments de mémoire flash comme éléments de stockage des données).
  • Un pilote possédant la version 471.68 au minimum.

Ces contraintes d’utilisation montrent pour le moment que cette technologie n’est donc pas accessible à un grand nombre de personnes, puisqu’elle demande des composants d’une certaine valeur. Cette IA est donc plus fréquemment utilisée par des professionnels.

Le fonctionnement de l’IA

Comme indiqué ci-dessus, cette technique est basée sur un système d’utilisation simple afin qu’elle soit accessible à tous. Ainsi lorsque nous nous retrouvons sur ce logiciel l’on retrouve différents paramètres qui nous seront utiles lors de la création mais aussi de l’exportation de notre dessin une fois terminé.

L’on distingue donc 3 zones ou se regroupe les paramètres :

  1. La première partie est destinée à la création d’un point de vue technique du dessin puisque l’on peut retrouver des fonctionnalités telles que le pinceau servant a choisir l’environnement que l’on souhaite utiliser. Mais aussi un outil nous aidant à tracer des lignes droites et bien évidemment la fonctionnalité gommes et remplissage. D’un point de vue pratique la bêta propose une fonctionnalité permettant de choisir précisément une couleur, ou bien celle permettant choisir l’épaisseur de la pointe du stylo.
  2. Dans la seconde partie l’on retrouve tout ce qui rapporte au fichier et à l’affichage de celui-ci. Ainsi l’on a l’opportunité d’ouvrir une nouvelle feuille vierge afin d’effectuer un nouveau dessin mais aussi ce qui concerne l’enregistrement et l’exportation de ce dessin. De plus, la loupe permet d’agrandir plus ou moins le dessin lors de sa création mais aussi l’on peut choisir de voir le dessin (à gauche) et le rendu final après l’intervention de l’IA (à droite) en même temps ou bien chaque rendu à part, c’est-à-dire ou l’un ou l’autre, c’est à vous de choisir.
  3. Enfin dans la troisième partie l’on retrouve l’aspect graphique. Notamment avec le choix d’une vingtaine de matériaux comme par exemple avec des nuages, des montagnes, de l’herbe, une rivière et de la brume et de la pluie ainsi qu’une quinzaine d’autres textures. De plus l’on retrouve l’opportunité d’utiliser des « layers » tout comme Photoshop par exemple cela nous donne l’opportunité d’avoir plusieurs calques superposés. Enfin l’on a accès à 9 styles ce qui permet d’appliquer au dessin une ambiance différente telle qu’un coucher de soleil ou bien un environnement ensoleillé.

Comme l’on dit « une image vaut mieux que mille mots« , alors je vous mets à disposition différent dessin réaliser avec Nvidia Canvas.

Vous pouvez donc voir le potentiel juste immense de cette intelligence artificielle qui est en constante évolution, il ne vous reste qu’à la télécharger grâce à ce lien pour les tester de vous-même et laisser s’exprimer votre créativité : https://www.nvidia.com/fr-fr/studio/canvas/

En conclusion j’espère que ce tutoriel que j’ai moi-même pris du plaisir à réaliser, vous aura permis de découvrir cette intelligence artificielle et qu’il vous guidera lors de son utilisation.

Tutoriels

Comment détourer une image en 2 clics avec l’IA

  • par

Dans ce tutoriel, je vais vous montrer comment détourer gratuitement une image en quelques secondes avec l’Intelligence Artificielle Arc Tencent.

Introduction

Le détourage d’image est une technique utilisée pour séparer un objet ou une personne d’un arrière-plan dans une image. Cela peut être utile pour ajouter des effets spéciaux à une image, pour enlever un arrière-plan indésirable ou simplement pour mettre en valeur un objet ou une personne.

Le détourage d’image peut être un processus long et fastidieux lorsqu’il est effectué manuellement, mais heureusement, il existe maintenant des outils d’IA qui permettent de détourer rapidement et facilement une image.

Présentation de l’outil ARC Tencent

L’IA de Tencent est un service de intelligence artificielle développé par Tencent, une entreprise chinoise spécialisée dans les technologies de l’information et de la communication.

Elle utilise des technologies avancées de deep learning et de machine learning pour fournir des résultats de haute qualité et des performances rapides. L’IA de Tencent est utilisée par de nombreuses entreprises et organisations à travers le monde pour améliorer leurs opérations et leur productivité.

Simple et rapide, ce service en ligne gratuit offrira de meilleurs résultats que RemoveBG et vous permettra des résultats téléchargeables en Full HD.

L’IA, c’est quoi ?

L’intelligence artificielle (IA) est un domaine de la science informatique qui vise à créer des programmes informatiques capables de réaliser des tâches qui nécessiteraient de l’intelligence humaine, comme la reconnaissance de la parole, la traduction de langues, le raisonnement et la prise de décision.

Il existe plusieurs types d’IA, notamment l’IA faible (également appelée IA de premier ordre) et l’IA forte (également appelée IA de deuxième ordre). L’IA faible est capable de réaliser des tâches spécifiques mais ne peut pas raisonner ou prendre des décisions de manière autonome. L’IA forte, en revanche, est capable de raisonner et de prendre des décisions de manière autonome, comme le ferait un humain.

L’IA est utilisée dans de nombreux domaines, notamment la robotique, la reconnaissance de la parole, la traduction, la finance et les jeux vidéo. Elle est également utilisée pour améliorer l’efficacité et la productivité dans les entreprises et les organisations.

Comment détourer son image

Voici les étapes simples à suivre pour détourer une image grâce à l’IA de Tencent :

1/ Tout d’abord, il faut aller sur son navigateur et dans la barre d’URL taper l’adresse ci-dessous afin de se rendre sur le site en ligne.

2/ Une fois sur le site, choisissez la version qui vous semble la mieux (souvent la V1.2 donne de meilleurs résultats, sur les cheveux par exemple) Vous pouvez déjà tester l’IA avec les 3 images proposé.

3/ A présent, cliquez sur Upload (en bleu) pour détourer l’image que vous souhaitez.

4/ Choisissez votre image (ici j’ai choisi un lion)

5/ Attendez quelques secondes et voilà le résultat !

6/ Vous n’avez plus qu’à la télécharger en cliquant sur Download.

En quelques secondes seulement mon lion a été parfaitement détouré automatiquement, sans faire quoi que ce soit de ma part si ce n’est qu’attendre.

Autres fonctionnalités de restauration

Il y a 2 autres fonctionnalités, « Face Restoration » qui va permettre de rendre une photo flou très nette et « Animation Enhancement » qui fait la même chose mais sur des illustrations, des dessins…

Voici un aperçu, c’est le même principe que pour le détourage d’image.

Conclusion

En suivant les étapes décrites dans ce tutoriel, vous avez appris comment détourer gratuitement une image en 2 clics avec l’IA de Tencent, que peut être très utile pour des miniatures Youtube par exemple.

Si vous souhaitez ajouter des modifications ou des retouches à l’image détourée, vous pouvez utiliser les outils d’édition d’image disponibles dans l’application Tencent AI Lab.

L’objectif de ce tutoriel était de vous montrer comment utiliser l’IA de Tencent pour détourer facilement et rapidement une image, sans avoir besoin de compétences en retouche photo ou en détourage manuel.

Tutoriels

Comment utiliser DALL-E 2 ?

  • par

DALL-E 2 est une puissante intelligence artificielle conçue pour générer du contenu visuel à partir de textes de description. Il est capable de créer des images de tout ce que vous pouvez imaginer, simplement en tapant une description de ce que vous voulez voir. Dans ce tutoriel, nous vous guiderons pas à pas à travers les étapes de base pour utiliser DALL-E 2. Vous apprendrez comment formuler des requêtes de génération d’images, comment naviguer dans l’interface de l’outil et comment enregistrer et télécharger vos créations.

Vidéo

Où se rendre?

Allez sur le site Web de DALL-E 2 (https://dall-e.openai.com/)

Capture du site.

Décrire son image.

Tapez une description de l’image que vous souhaitez générer dans la boîte de texte. Vous pouvez utiliser n’importe quel type de description, allant de concepts simples à des combinaisons complexes de concepts visuels et textuels. Par exemple, vous pouvez taper « un chat avec des ailes et une queue de lion », « un robot qui joue du violoncelle », ou « un paysage de montagne avec un arbre en forme de cœur ».

Capture de la boîte de texte.

Générer son image.

Cliquez sur le bouton « Generate » pour lancer le processus de génération de l’image. DALL-E 2 va utiliser votre description pour générer une image et l’afficher sur la page. Selon la complexité de votre description et la puissance de votre ordinateur, cela peut prendre quelques secondes à plusieurs minutes.

Capture prise pendant le téléchargement.

Afficher son image.

Lorsque l’image est générée, vous pouvez l’afficher en taille réelle en cliquant dessus.

Capture des images générées.
Capture après avoir cliqué sur une image.

Variations.

Vous pouvez également utiliser le bouton « Variations » pour afficher d’autres images qui ressemble a la votre.

Capture des variations de l’image.

Filtre et modification de l’image.

Vous pouvez également utiliser les options de filtre et de modification de l’image pour ajuster l’apparence de l’image générée. Pour cela, appuyer sur « Edit ». Prenez en main la gomme.

Capture de l’onglet d’édition.

Vous pouvez a présent effacer une partie de votre image et décrire par quoi vous voulez qu’elle soit remplacé.

Capture du gommage.

Appuyer sur « Generate ».

Capture des résultats.

De plus vous pouvez générer la suite de votre image. Prenez en main le premier outil.

Vous pouvez a présent déplacer une partie de votre image et décrire par quoi vous voulez qu’elle soit compléter.

Capture du décalage de l’image.

Exemple de l’outil expliqué précédemment.

Téléchargement de son image.

Si vous êtes satisfait de l’image générée, vous pouvez télécharger l’image en cliquant sur le bouton « Save ». Vous pouvez choisir entre plusieurs formats de fichier, tels que PNG, JPG et GIF.

Partager son image.

Si vous souhaitez enregistrer votre travail et partager vos images générées avec d’autres personnes, vous pouvez vous connecter avec votre compte OpenAI ou créer un nouveau compte. Vous pouvez alors enregistrer vos images dans votre bibliothèque et les partager via un lien ou en les publiant sur les réseaux sociaux.

A savoir.

Il est important de noter que DALL-E 2 est encore en développement et que ses résultats peuvent varier en qualité et en cohérence avec la description donnée. Cependant, c’est un outil amusant et créatif pour expérimenter avec des combinaisons de concepts

Art

Perspective : un paysage Synthwave

Dans le cadre de la 5ème édition du dispositif “Regards de Géomètre”, nous avons décidé dans le thème « Perspective » de produire un paysage synthwave.

Vidéo du projet

Origines de la Synthwave

Avant tout la synthwave est un genre musical électronique ayant émergé dans les années 2000/2010 qui s’inspire d’éléments des années 80. Et c’est justement dans les clips de ces musiques que l’on va retrouver ce type d’image.

Pour en savoir plus nous vous conseillons cette vidéo qui explique brièvement les origines.

Le Projet

Revenons donc au projet. Pour ce projet nous avons donc décidé de produire une image d’un paysage synthwave. Pour cela nous utilisons le module turtle ainsi que le module random, le module turtle est utilisé pour produire l’image est le module random est utilisé pour les étoiles de l’image où la taille et leur position est générée aléatoirement nous avons également utilisé le script permettant d’exporter une image générée par turtle en .png que vous pouvez retrouver ici.

Structure du script

Pour la structure du script nous avons décidé de découper chaque partie de l’image (pavage, fond, étoiles, soleil, ville et montagnes) afin de créer des fonctions et à la fin nous les avons toutes appelées dans un ordre précis pour que les différentes parties de l’image soit dans leur plan respectif.

Analyse du script

Nous allons donc analyser le script.

Commençons par l’appel des modules et la mise en place de turtle.

from turtle import *
from random import randint
# vérification des modules importés
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 = "Perspective - Un paysage Synthwave"
title(titre+" | Au lycée, la meilleure spécialité, c'est la spé NSI")
setup(1280, 720) # définit la taille de la fenêtre
colormode(255) # permet l'utilisation de couleurs rgb
speed(0) #Remplaçable par tracer(2) (10x plus rapide) mais si il est utilisé des lignes du pavage peuvent manquer
hideturtle() #dissimule la tortue

On appelle les fonctions turtle, random avec pour random uniquement randint et on utilise une partie du script « exporter une image générée par turtle » pour 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 la vérification on met en place le titre de la fenêtre qui va affiché le rendu ainsi que sa taille. Enfin on définit le type de couleurs utilisées (R,G,B), la vitesse de la tortue, et on dissimule la tortue (c’est plus joli).

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(239 + rciel), round(41 + gciel), round(209 + bciel))
        forward(1280)
        hauteur += 1
        goto(-640, hauteur)
        rciel += (-29/180)
        gciel += (2/45)
        bciel += (7/720)

Pour le fond on aurait pu utiliser une fonction qui crée un rectangle et qui le remplit avec fill_rect, cependant la couleur dans ce cas est uni ce qui ne nous intéresse pas. Nous avons donc produit un script qui fait un fond dégradé qui fait avancer la tortue sur une ligne d’un pixel de large et à la fin de cette ligne la tortue est envoyé grâce à un goto à la ligne d’après 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. Tout ceci est arrondi car turtle n’est pas compatible avec des arguments à virgule (pour la fonction pencolor en tout cas).

Par la suite la fonction qui produit les étoiles a été codée :

def etoile():
    for i in range(90):
        penup()
        goto(randint(-720,720), randint(0,360))
        pendown()
        pencolor(255, 255, 255)
        lcercle = randint(1,3)
        fillcolor('white')
        begin_fill()
        circle(lcercle)
        end_fill()

Pour les étoiles on définit aléatoirement leur position sur la moitié haute de l’image, on les met en blanc, on définit aussi aléatoirement la taille de l’étoile et on créer l’étoile avec sa position, et sa taille en aléatoire puis on refait ce processus 90 fois pour avoir 90 étoiles.

Ensuite nous avons le soleil (Le script affiché n’est qu’une petite partie du script total du soleil car il est très long et qu’il se répète, il est donc inutile de commenter la suite) :

def soleil():
    penup()
    liste1 = [10,7,5,4,3,3,3,3,2,2,2,2,2,2,2,1,2,1,2,1,1,2,1,1,1,1,2,1,1,1]
    liste2 = [1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]
    pliste1 = 0
    pliste2 = 0
    rsoleil = 0
    gsoleil = 0
    bsoleil = 0
    lsoleil = 8
    hauteur = 30
    goto(0,30)
    pendown()
    for i in range(15):
        pencolor(round(255 + rsoleil), round(23 + gsoleil), round(226 + bsoleil))
        forward(lsoleil)
        backward(2*lsoleil)
        hauteur += 1
        lsoleil += liste1[pliste1]
        pliste1 += 1
        goto(0, hauteur)
        rsoleil += (0)
        gsoleil += (114/101)
        bsoleil += (-203/202)
    forward(lsoleil)
    backward(2*lsoleil)
    penup()

Pour le soleil nous réutilisons le script du dégradé, cependant nous l’avons modifier pour que le point d’origine de la tortue soit au centre du rectangle et que la longueur de chaque ligne soit défini par une liste (ce qui permet de faire un cercle en prenant les longueur d’un cercle utilisable en pixel art). Pour ce qui est des endroits ou le soleil est coupé la tortue fait le tracé mais on a utilisé la fonction penup() qui fait que la tortue ne dessine plus.

Après nous avons la fonctions des montagnes (Encore une fois le script n’est pas complet car il se répète encore 3 fois après.) :

def montagne():
    #montagne derrière la première
    penup()
    goto(-480,0)
    fillcolor(110, 27, 188)
    begin_fill()
    for i in range(3):
        forward(250)
        left(120)
    end_fill()
    
    goto(-480,0)
    pencolor(51, 210, 246)
    ymontagne = 10
    for i in range(11):
        pendown()
        goto(-355,ymontagne)
        goto(-230,0)
        penup()
        goto(-480,0)
        ymontagne += 20

Pour le script des montagnes nous avons utilisé le script pour faire des triangles équilatéraux retrouvable ici. Et ensuite nous avons utilisé un ‘for i in range’ pour faire des goto enchaîné pour faire les lignes des montagnes.

Ensuite nous avons les fonctions de la ville. Pourquoi les fonctions car il y a une fonction pour chaque bâtiment différent ainsi qu’une fonction finale qui définit l’ordre des bâtiments.

def bat1():
    penup()
    rbat = 0
    gbat = 0 
    bbat = 0
    hauteur = 0
    pendown()
    xturtle, yturtle = pos()
    while hauteur != 72:
        pencolor(round(125 + rbat), round(35 + gbat), round(216 + bbat))
        forward(42)
        hauteur += 1
        goto(xturtle, hauteur)
        rbat += (-5/3)
        gbat += (-7/15)
        bbat += (-72/25)
    forward(42)
    penup()
    right(90)
    forward(72)
    left(90)

Pour le bâtiment 1 il y a un dégradé (toujours le même script) puis on fait que la tortue finisse le bâtiment en bas à droite de ce dernier pour pouvoir enchainer les bâtiments.

fun fact : Au début nous n’avions pas prévu les quelques lignes à la fin pour que la tortue puisse enchaîner les bâtiments sans que les fonctions des bâtiments aient besoin d’être modifiés ce qui nous a amené à avoir tous les bâtiments qui se chevauchaient.

def ville():
    penup()
    goto(-320,0)
    bat3(), bat2(), bat1(), bat4() ,bat3(), bat4(), bat3(), bat2(), bat1(), bat2(), bat1(), bat3(), bat1(), bat4(), bat2(), bat1(), bat3(), bat1(), bat4(), bat3()

Et à la fin on a fait la fonction ville qui appelle dans l’ordre choisi les bâtiments. Le goto permet de définir où commence le premier bâtiment, les autres se mettent juste après le premier sans se chevaucher ni laisser un espace.

Par la suite nous avons le pavage (très long aussi, il sera donc coupé) :

def pavage():
    colormode(255)
    pensize(5)
    speed(0)
    rciel = 0
    gciel = 0 
    bciel = 0
    hauteur = -360
    penup()
    goto(-640,-360)
    pendown()
    while hauteur != 0:
        pencolor(round(15 + rciel), round(4 + gciel), round(76 + bciel))
        forward(1280)
        hauteur += 1
        goto(-640, hauteur)
        rciel += (91/180)
        gciel += (1/36)
        bciel += (7/18)

Pour le début du pavage on retrouve encore le script du dégradé mais avec les couleurs modifiées.

pencolor(229, 123, 240)
    #Lignes au dessus du pavage
    pensize(4),penup(),goto(-640,0),pendown(),goto(640,0),pensize(2),penup(),goto(-640, 0),pendown()
    #lignes gauche
    penup(),goto(-20.00,0),pendown(),goto(-60.00,-360.00),penup(),goto(-60.00,0),pendown(),goto(-180.00,-360.00),penup(),goto(-100.00,0),pendown(),goto(-300.00,-360.00),penup(),goto(-140.00,0),pendown(),goto(-420.00,-360.00),penup(),goto(-180.00,0),pendown(),goto(-540.00,-360.00),penup(),goto(-220.00,0),pendown(),goto(-660.00,-360.00),penup(),goto(-260.00,0),pendown(),goto(-780.00,-360.00),penup(),goto(-300.00,0),pendown(),goto(-900.00,-360.00),penup(),goto(-340.00,0),pendown(),goto(-1020.00,-360.00),penup(),goto(-380.00,0),pendown(),goto(-1140.00,-360.00),penup(),goto(-420.00,0),pendown(),goto(-1260.00,-360.00),penup(),goto(-460.00,0),pendown(),goto(-1380.00,-360.00),penup(),goto(-500.00,0),pendown(),goto(-1500.00,-360.00),penup(),goto(-540.00,0),pendown(),goto(-1620.00,-360.00),penup(),goto(-580.00,0),pendown(),goto(-1740.00,-360.00),penup(),goto(-620.00,0),pendown(),goto(-1760.00,-360.00)
    #lignes droites
    penup(),goto(20,0),pendown(),goto(60.00,-360.00),penup(),goto(60.00,0),pendown(),goto(180.00,-360.00),penup(),goto(100.00,0),pendown(),goto(300.00,-360.00),penup(),goto(140.00,0),pendown(),goto(420.00,-360.00),penup(),goto(180.00,0),pendown(),goto(540.00,-360.00),penup(),goto(220.00,0),pendown(),goto(660.00,-360.00),penup(),goto(260.00,0),pendown(),goto(780.00,-360.00),penup(),goto(300.00,0),pendown(),goto(900.00,-360.00),penup(),goto(340.00,0),pendown(),goto(1020.00,-360.00),penup(),goto(380.00,0),pendown(),goto(1140.00,-360.00),penup(),goto(420.00,0),pendown(),goto(1260.00,-360.00),penup(),goto(460.00,0),pendown(),goto(1380.00,-360.00),penup(),goto(500.00,0),pendown(),goto(1500.00,-360.00),penup(),goto(540.00,0),pendown(),goto(1620.00,-360.00),penup(),goto(580.00,0),pendown(),goto(1740.00,-360.00),penup(),goto(620.00,0),pendown(),goto(1760.00,-360.00)
    #Lignes horizontales
    penup(),goto(-640, -300),pendown(),goto(640, -300),penup(),goto(-640, -240),pendown(),goto(640, -240),penup(),goto(-640, -190),pendown(),goto(640, -190),penup(),goto(-640, -140),pendown(),goto(640, -140),penup(),goto(-640, -100),pendown(),goto(640, -100),penup(),goto(-640, -70),pendown(),goto(640, -70),penup(),goto(-640, -40),pendown(),goto(640, -40),penup(),goto(-640, -15),pendown(),goto(640, -15),

On a par la suite énormément de goto afin de faire le quadrillage du pavage.

Pour produire l’image finale nous avons les appels des différents fonctions à la fin :

#appel de toutes les fonctions
fond(), etoile(), soleil(), montagne(), ville(), pavage()

Et pour exporter l’image finale en .png il y a la suite du script pour exporter une image générée par turtle en .png utilisé au début du script.

#enregistrement de l'image finale avec vérification des modules importés
image = getcanvas()
nom_du_fichier_sans_extension=titre+"_"+hex(randint(2**30+2**25,2**30+2**25+2**24-1))[2:]
image.postscript(file=nom_du_fichier_sans_extension+".ps", colormode='color')
try:
    psimage = Image.open(nom_du_fichier_sans_extension+".ps")
    psimage.load(scale=2)
    psimage_resized = psimage.resize((1280, 720))
    psimage.save(nom_du_fichier_sans_extension+".png")
    print(nom_du_fichier_sans_extension+".png", psimage.size, "sauvegardé dans le dossier")    
except:
    if not pillow_installed:
        print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
        print("https://nsi.xyz/py2png")
    else:
        print("Oops! - 'ghostscript' not installed- RTFM :")
        print("https://nsi.xyz/py2png")
exitonclick()

Le script va donc générer une image en .ps et la convertir en .png avec un nom généré aléatoirement pour éviter que à chaque fois que vous générez une image l’image soit écrasée

Télécharger le .py

Télécharger

L’image finale

Art

Astronomie : Un semblant de liberté

« C’est dur, oui, il a tant cherché sa place dans l’univers : société, nature sauvage, vie luxueuse,… mais rien de tout ça ne lui convenait. Se tournant vers le ciel, c’était peut-être parmi les étoiles que se trouvait sa place… »


Introduction

À l’aide du module Turtle, on va pouvoir créer une image en python, animée ou non.
Aujourd’hui, ce sera alors plutôt un dessin que nous générerons par notre code, de plus, celle-ci sera différente à chaque exécution !
Nous allons alors décortiquer des parties de celui-ci afin de le comprendre, si ce n’est pas déjà le cas ! 😉


Une mise en bouche qui nous prépare

colormode(255)
color(5,9,44)
goto(-640,0)
pensize(1000)
forward(1000)

Ce bloc de code permet de préparer le dessin en y installant un fond bleu nuit rappelant l’espace.
La couleur est définie dans les 2 premières lignes, ensuite on se rend à des coordonnées hors du champ de vision puis on trace un trait très épais.


Des fonctions par-ci, des fonctions par-là

def etoile():
    pensize(2)
    couleur = randint(0,3)
    if couleur == 0:
        color(250, 137, 25)
    else:
        color(247,247,36)
    for _ in range(5):
        forward(10)
        right(144)

Le bloc de code suivant est une fonction, elle nous permet de définir une suite d’instructions qu’on peut utiliser par la suite.
Elle dessine une étoile tout en utilisant un autre module permettant d’utiliser l’aléatoire, à l’aide de celui-ci et de structure conditionnelles, on choisit aléatoirement entre 2 couleurs pour l’étoile.
Puis, on la trace à l’aide d’une boucle bornée. 😵

def position_aleatoire():
    penup()
    x = randint(-640,640)
    y = randint(-320,320)
    goto(x,y)
    pendown()

Cette seconde fonction diffère de la 1ère par son utilité-même : elle permet de choisir une position aléatoire.
La fonction génère aléatoirement des coordonnées dans un intervalle défini, ici, celle de la fenêtre puis elle s’y rend.

for _ in range(42):
    position_aleatoire()
    type_etoile = randint(0,2)
    if type_etoile == 0:
        etoile_2()
    else:
        etoile()

C’est alors que la magie entre en scène, on manipule les fonctions précédemment créées afin de produire un splendide ciel étoilé !
On se rend à un endroit aléatoire grâce à la 2ème fonction puis on dessine une étoile grâce à la 1ère fonction (et une autre produisant un autre type d’étoile), et ceci 42 fois !! 😱


Des éléments de décoration


D’autres éléments constituant l’image proviennent de fonctions, prenons ici l’exemple de la fusée :

def fusee():
    left(55)
    penup()
    goto(-100,-40)
    pendown()
    corps_fusee()
    for i in range(2):
        penup()
        goto(-125+i*275/100*25,-50-i*5/2*20)
        pendown()
        moteur()
    for i in range(2):
        penup()
        goto(-15+i*35*135/100,-65/2+i*50*135/100)
        pendown()
        hublot()
    right(30)
    penup()
    goto(15,125)
    pendown()
    toit()


On peut voir une différence notable avec les fonctions précédentes, cette fonction est elle-même constituée de fonctions : « corps_fusee » ; « moteur » ; « hublot » et « toit ».
Et comme dit plus tôt, on utilise et manipule ces fonctions, par exemple en les utilisant plusieurs fois dans une boucle, en définissant un angle au préalable,… et ça ne s’arrête pas là ! on pourrait très bien utiliser la fonction définissant la fusée afin de lui donner une autre utilité !

C’est alors en usant de fonctions, de boucles et de structures conditionnelles qu’on peut facilement produire une œuvre avec le module Turtle, mais tout cela ne peut se réaliser qu’avec de la pratique, car comme j’ai dit : « C’est en programmant que l’on devient programmeur ».

L’image finale

Télécharger le .py

script_imageTélécharger
Art

Urbanisme : La skyline de New York

Pour ce premier projet en classe de première NSI nous avons choisi comme thème l’urbanisme. Nous avons souhaiter créer un projet original. Ce programme a pour but de réaliser un rendu graphique qui se rapproche au maximum du flat design. 

C’est quoi le flat design ?

Petit point de culture générale : Très brièvement le flat design est un style graphique caractérisé par le minimalisme et la simplicité des éléments présents sur le rendu. On ne cherche pas à faire à être dans le détail avec des ombres, des effets 3d… mais à être dans la simplicité avec une recherche en amont. Le flat design est aujourd’hui utilisé dans différentes catégories telle que l’illustration ou encore dans l’UI design où il consistera à obtenir un rendu fluide et ergonomique pour l’utilisateur. Un très grand artiste français qui utilise le flat design est Malika Favre voilà quelques exemples de créations qu’il a pu réaliser :

Les Recherches

Dans un premier temps pour réaliser ce projet nous avons dû faire différentes recherches sur internet. Les recherches finies, nous avons créer un moodboard pour mettre nos idées au claire et pour avoir de l’inspiration.

Nous avons sélectionné une image de la Skyline sur internet et nous l’avons directement modifiée sur Photoshop pour ne pas avoir de soucis avec les droits d’auteur.

Skyline/ Photoshop

Dans un second temps, nous nous sommes mis d’accord pour ne pas créer une simple Skyline mais bien plus. Notre point de départ est un couché de soleil avec des couleurs pastelles pour obtenir un rendu idéal qui se rapproche du flat design.

Une fois que nous étions d’accord sur les détails de notre projet, nous avons commencé le script phyton. Nous nous sommes divisés le travail en deux groupes :

  • Skyline : Noah / Henry
  • Ciel : Constance

Le code en entier

from turtle import *
from random import randint

#Lever de soleil

colormode(255)
bgcolor("#ffb399")

def disque(rayon, x, y, couleur=(1, 1, 1)):
    penup()
    goto(x, y-rayon)
    pendown()
    pencolor(couleur)
    fillcolor(couleur)
    begin_fill()
    circle(rayon)
    end_fill()
    
x, y = (0,-120)
radius = (500)
color = ("#ffc6b3")
disque(radius, x, y, color) 

x, y = (0,-120)
radius = (400)
color = ("#ffd9cc")
disque(radius, x, y, color) 
    
x, y = (0,-120)
radius = (300)
color = ("#ffece6")
disque(radius, x, y, color)     

x, y = (0,-120)
radius = (200)
color = ('white')
disque(radius, x, y, color)   


def arrondi_gauche():
    for i in range(180):
        left(1)
        forward(7/45)
        
def arrondi_droit():
    for i in range(180):
        right(1)
        forward(7/100)


def nuage():
    speed(10)
    pendown()
    width(2)
    pencolor("#ffffb3")
    fillcolor("#ffffb3")
    begin_fill()
    forward(210)
    arrondi_gauche()
    forward (21)
    arrondi_droit()
    forward(14)
    arrondi_gauche()
    forward(70)
    arrondi_droit()
    forward(56)
    arrondi_gauche()
    forward(28)
    arrondi_droit()
    forward(14)
    arrondi_gauche()
    forward(20)
    for i in range(90):
        right(1)
        forward(7/50)
    for i in range(90):
        left(1)
        forward(7/45)
    forward(35)
    for i in range(90):
        left(1)
        forward(7/45)
    for i in range(90):
        right(1)
        forward(7/50)
    forward(21)
    arrondi_gauche()
    forward(14)
    arrondi_droit()
    forward(49)
    arrondi_gauche()
    forward(42)
    arrondi_droit()
    forward(56)
    arrondi_gauche()
    forward(7)
    arrondi_droit()
    forward(42)
    arrondi_gauche()
    forward(10)
    end_fill()

penup()
goto(-450,-40)
nuage()

penup()
goto(300,55)
nuage()

penup()
goto(-50,200)
nuage()

#Skyline

pensize(3)
def building1(longueur,largeur, couleur=(1,1,1)):
    pendown()
    pencolor(couleur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur/1.5)
    left(90)
    forward(longueur/2)
 
def building2(longueur, largeur, couleur=(1,1,1)):
    etage(longueur, largeur/5)
    etage(longueur/2 , largeur/5)
    etage(longueur/3 , largeur/5)
    left(80)
    forward(longueur/2)

def etage(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)

def etage_inverse(longueur, largeur, couleur=(1,1,1)):
    forward(largeur)
    left(270)
    forward(longueur)
    left(90)
def building2_inverse(longueur, largeur, couleur=(1,1,1)):
    right(160)
    forward(longueur/2)
    left(80)
    etage_inverse(longueur/3, largeur/5)
    etage_inverse(longueur/2 , largeur/5)
    etage_inverse(longueur, largeur/5)

def building3(longueur, largeur, couleur=(1,1,1)):
   forward(longueur/3)
   left(90)
   forward(longueur)
   right(90)
   forward(largeur)
   right(90)
   forward(longueur/4)
   left(90)
   forward(largeur)
   left(90)
   forward(longueur/5)
   right(90)
   forward(largeur)
   right(90)
   forward(longueur/2)
   
def building4(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur/3)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    left(90)
    forward(longueur-30)
    right(90)
    forward(largeur+25)
    right(90)
    forward(longueur+20)
    
def building5(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur/2)
    left(45)
    forward(longueur/2)
    right(225)
    forward(longueur/3)
    right(90)
    forward(largeur+5)
    right(90)
    forward(longueur+30)
    
def building6(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur)
    left(90)
    forward(longueur)
    right(30)
    forward(longueur/8)
    left(30)
    forward(30)
    right(30)
    forward(longueur/8)
    left(30)
    forward(60)

def building6_reverse(longueur, largeur, couleur=(1,1,1)):
    left(180)
    forward(60)
    left(30)
    forward(longueur/8)
    right(30)
    forward(30)
    left(30)
    forward(longueur/8)
    right(30)
    forward(longueur)
    left(90)
    forward(largeur)
    
def building7(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    left(90)
    forward(longueur/3)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur-130)
    left(90)
    forward(largeur)
    right(90)
    forward(longueur-50)
    left(35)
    forward(largeur*2)
    right(35)
    forward(longueur-75)


def building8(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur/2)
    left(35)
    forward (largeur)
    right(35)
    forward(longueur-20)
       
    
    
penup()
fillcolor("#80586D")
begin_fill()
goto(-630,-350)
goto(-630,-300)
building1(60,30, couleur=("#80586D"))
building2(150,80 , couleur=("#80586D"))
building2_inverse(150,80 , couleur=("#80586D"))
building3(120,30, couleur=("#80586D"))
building4(100,40, couleur=("#80586D"))
building5(80,25, couleur=("#80586D"))
building6(275,50, couleur=("#80586D"))
building6_reverse(275,50, couleur=("#80586D"))
right(90)
building4(90,30, couleur=("#80586D"))
building7(165,35, couleur=("#80586D"))
left(90)
building3(170,35, couleur=("#80586D"))
building8(150,45, couleur=("#80586D"))
pendown()
goto(630,-350)
goto(-630,-350)
end_fill()



penup()
fillcolor("#01343D")
begin_fill()
left(90)
goto(-620,-350)
building1(60,30, couleur=("#01343D"))
building2(150,80 , couleur=("#01343D"))
building2_inverse(150,80 , couleur=("#01343D"))
building3(120,30, couleur=("#01343D"))
building4(100,40, couleur=("#01343D"))
building5(80,25, couleur=("#01343D"))
building6(275,50, couleur=("#01343D"))
building6_reverse(275,50, couleur=("#01343D"))
right(90)
building4(90,30, couleur=("#01343D"))
building7(165,35, couleur=("#01343D"))
left(90)
building3(170,35, couleur=("#01343D"))
building8(150,45, couleur=("#01343D"))
pendown()
goto(-630,-350)
end_fill()

Le Fond 

def disque(rayon, x, y, couleur=(1, 1, 1)):
    penup()
    goto(x, y-rayon)
    pendown()
    pencolor(couleur)
    fillcolor(couleur)
    begin_fill()
    circle(rayon)
    end_fill()
    
x, y = (0,-120)
radius = (500)
color = ("#ffc6b3")
disque(radius, x, y, color) 

x, y = (0,-120)
radius = (400)
color = ("#ffd9cc")
disque(radius, x, y, color) 
    
x, y = (0,-120)
radius = (300)
color = ("#ffece6")
disque(radius, x, y, color)     

x, y = (0,-120)
radius = (200)
color = ('white')
disque(radius, x, y, color)   


def arrondi_gauche():
    for i in range(180):
        left(1)
        forward(7/45)
        
def arrondi_droit():
    for i in range(180):
        right(1)
        forward(7/100)
Fond

Pour réaliser le fond, j’ai adapté la fonction disque des exemples donnés afin de faire un dégradé de disques partant d’un peu plus bas que le centre et du plus clair au plus foncé. De cette manière, le disque au centre est blanc et représente donc le Soleil. De plus, les disques autour forment un dégradé de couleurs modélisant le levé du Soleil dans le ciel.

Les nuages 

def nuage():
    speed(10)
    pendown()
    width(2)
    pencolor("#ffffb3")
    fillcolor("#ffffb3")
    begin_fill()
    forward(210)
    arrondi_gauche()
    forward (21)
    arrondi_droit()
    forward(14)
    arrondi_gauche()
    forward(70)
    arrondi_droit()
    forward(56)
    arrondi_gauche()
    forward(28)
    arrondi_droit()
    forward(14)
    arrondi_gauche()
    forward(20)
    for i in range(90):
        right(1)
        forward(7/50)
    for i in range(90):
        left(1)
        forward(7/45)
    forward(35)
    for i in range(90):
        left(1)
        forward(7/45)
    for i in range(90):
        right(1)
        forward(7/50)
    forward(21)
    arrondi_gauche()
    forward(14)
    arrondi_droit()
    forward(49)
    arrondi_gauche()
    forward(42)
    arrondi_droit()
    forward(56)
    arrondi_gauche()
    forward(7)
    arrondi_droit()
    forward(42)
    arrondi_gauche()
    forward(10)
    end_fill()

penup()
goto(-450,-40)
nuage()

penup()
goto(300,55)
nuage()

penup()
goto(-50,200)
nuage()

Pour rajouter un effet naturel au ciel, on a décidé d’ajouter des nuages avec une couleur et une forme adaptée au moment de la journée du levé de Soleil. J’ai donc crée une fonction nuage qui comprend également deux autres fonctions pour arrondir chaque bosse des nuages. De cette façon, le script est bien plus court. Pour faire les arrondis, j’ai d’abord fait le script d’un cercle, puis je l’ai adapté dans chacune des fonctions afin que sa largeur puisse varier.

La Skyline 

def building1(longueur,largeur, couleur=(1,1,1)):
    pendown()
    pencolor(couleur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur/1.5)
    left(90)
    forward(longueur/2)
 
def building2(longueur, largeur, couleur=(1,1,1)):
    etage(longueur, largeur/5)
    etage(longueur/2 , largeur/5)
    etage(longueur/3 , largeur/5)
    left(80)
    forward(longueur/2)

def etage(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)

def etage_inverse(longueur, largeur, couleur=(1,1,1)):
    forward(largeur)
    left(270)
    forward(longueur)
    left(90)
def building2_inverse(longueur, largeur, couleur=(1,1,1)):
    right(160)
    forward(longueur/2)
    left(80)
    etage_inverse(longueur/3, largeur/5)
    etage_inverse(longueur/2 , largeur/5)
    etage_inverse(longueur, largeur/5)

def building3(longueur, largeur, couleur=(1,1,1)):
   forward(longueur/3)
   left(90)
   forward(longueur)
   right(90)
   forward(largeur)
   right(90)
   forward(longueur/4)
   left(90)
   forward(largeur)
   left(90)
   forward(longueur/5)
   right(90)
   forward(largeur)
   right(90)
   forward(longueur/2)
   
def building4(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur/3)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    left(90)
    forward(longueur-30)
    right(90)
    forward(largeur+25)
    right(90)
    forward(longueur+20)
    
def building5(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur/2)
    left(45)
    forward(longueur/2)
    right(225)
    forward(longueur/3)
    right(90)
    forward(largeur+5)
    right(90)
    forward(longueur+30)
    
def building6(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur)
    left(90)
    forward(longueur)
    right(30)
    forward(longueur/8)
    left(30)
    forward(30)
    right(30)
    forward(longueur/8)
    left(30)
    forward(60)

def building6_reverse(longueur, largeur, couleur=(1,1,1)):
    left(180)
    forward(60)
    left(30)
    forward(longueur/8)
    right(30)
    forward(30)
    left(30)
    forward(longueur/8)
    right(30)
    forward(longueur)
    left(90)
    forward(largeur)
    
def building7(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    left(90)
    forward(longueur/3)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur-130)
    left(90)
    forward(largeur)
    right(90)
    forward(longueur-50)
    left(35)
    forward(largeur*2)
    right(35)
    forward(longueur-75)


def building8(longueur, largeur, couleur=(1,1,1)):
    left(90)
    forward(largeur)
    left(90)
    forward(longueur)
    right(90)
    forward(largeur)
    right(90)
    forward(longueur/2)
    left(35)
    forward (largeur)
    right(35)
    forward(longueur-20)
       
    
    
penup()
fillcolor("#80586D")
begin_fill()
goto(-630,-350)
goto(-630,-300)
building1(60,30, couleur=("#80586D"))
building2(150,80 , couleur=("#80586D"))
building2_inverse(150,80 , couleur=("#80586D"))
building3(120,30, couleur=("#80586D"))
building4(100,40, couleur=("#80586D"))
building5(80,25, couleur=("#80586D"))
building6(275,50, couleur=("#80586D"))
building6_reverse(275,50, couleur=("#80586D"))
right(90)
building4(90,30, couleur=("#80586D"))
building7(165,35, couleur=("#80586D"))
left(90)
building3(170,35, couleur=("#80586D"))
building8(150,45, couleur=("#80586D"))
pendown()
goto(630,-350)
goto(-630,-350)
end_fill()



penup()
fillcolor("#01343D")
begin_fill()
left(90)
goto(-620,-350)
building1(60,30, couleur=("#01343D"))
building2(150,80 , couleur=("#01343D"))
building2_inverse(150,80 , couleur=("#01343D"))
building3(120,30, couleur=("#01343D"))
building4(100,40, couleur=("#01343D"))
building5(80,25, couleur=("#01343D"))
building6(275,50, couleur=("#01343D"))
building6_reverse(275,50, couleur=("#01343D"))
right(90)
building4(90,30, couleur=("#01343D"))
building7(165,35, couleur=("#01343D"))
left(90)
building3(170,35, couleur=("#01343D"))
building8(150,45, couleur=("#01343D"))
pendown()
goto(-630,-350)
end_fill()
New York Skyline

Dans le cas de la Skyline, le principal défi a été d’éviter de reproduire la même chose. Donc pour remédier au problème, nous avons coder de nombreuses fonctions « def » pour initialiser les buildings. Ensuite, il s’agissait surtout de calculer les bâtiments et les étages car ils étaient tous hétérogènes. Enfin, il nous suffisait d’utiliser les fonctions en rentrant les mesures et définir les couleurs puis la Skyline de New York prend vie.

Conclusion

En réalisant ce projet, nous avons étudié l’architecture de New York en analysant les suites logiques de buildings en fonction de leurs tailles par exemple. Nous avons aussi travaillé sur la meilleure façon de représenter un lever de Soleil de manière simple et évidente en regardant des exemples sur des dessins et des photos. En python, on a appris à manipuler les fonctions pour exécuter des scripts sans les réécrire plusieurs fois (avec les arrondis des nuages par exemple). Nous avons aussi du travailler beaucoup avec les couleurs avec les plusieurs plans des buildings qui ont permis de donner du relief à l’image grâce aux couleurs mais aussi avec le dégradé du ciel pour qu’il paraisse naturel. Nous avons aussi du visualiser l’image finale en gardant le meilleur de différentes inspirations et tout calculer pour que l’image ne soit ni trop vide ni trop surchargée d’éléments. Cette réalisation avait pour but d’être esthétique, moderne et simple.4

Télécharger le .py

Si vous voulez l’essayer, vous trouverez le script ci-dessous, mais attention, les nuages prennent énormément de temp à s’exécuter !

Skyline New YorkTélécharger
Art

Musique : Pink Floyd et son album lumineux

Le choix de la pochette d’album « The Dark Side of the Moon » n’a, d’après les membres du groupe, pas de signification précise. Lassés des photographies chargées ou des collages compliqués, ceux-ci cherchaient un visuel simple et facile à retenir. C’est bien le cas puisque 50 ans après, l’image du spectre lumineux se dispersant à travers un prisme est presque toujours associée au groupe Pink Floyd.

Vidéo de présentation du projet

De la physique à la musique

Lors du feuilletage d’un manuel de physique, l’attention du graphiste des Pink Floyd a été retenue par une photographie en noir et blanc d’un prisme à travers lequel se dispersait la lumière. L’idée lui est alors venue de choisir cette image en guise de pochette d’album.

En physique, un spectre lumineux est le résultat de la décomposition de la lumière par un spectroscope. Il permet d’analyser celle ci grâce aux radiations qui la composent.

Cette image n’est pas sans rappeler les éclairages des concerts où des faisceaux lumineux traversent la scène en se modifiant au contact des musiciens, tel le spectre traversant le prisme.

De la musique à la NSI

Nous avons donc décidé de récréer numériquement cette pochette d’album. Pour ce faire, nous avons utilisé le langage python et l’émulateur Thonny.

Tout d’abord, nous avons instauré le fond de couleur noir en utilisant la fonction bgcolor().

Nous avons ensuite tracé le triangle principal en veillant à le placer au centre. Pour cela, nous avons mis pour point d’abscisse de départ la valeur « -100 » afin que la longueur du triangle soit de « 200 ».

Puis, nous nous sommes penchés sur la partie gauche de notre image en commençant par tirer un trait défini par ses points de coordonnées de départ et d’arrivée.

Effet dégradé à l’intérieur du triangle :

Vient ensuite une partie plus complexe : l’élargissement du trait en dégradé, partant de la couleur initiale du trait pour aller vers le noir de l’arrière plan.

Pour cela, le script effectue des traits en allers-retours (grâce à une boucle for), d’un point défini sur le triangle jusqu’au milieu du triangle. Pour chaque trait, l’opacité (a) diminue au fur et à mesure que le trait se rapproche du milieu du triangle. L’opacité est remise à sa valeur initiale (a=255) avant chaque traçage de trait.

turtle.colormode(255)
for i in range(20):
    penup()
    a = 255
    go to(-40, 100)
    for i in range(41):
        turtle.color(a,a,a)
        pendown()
        turtle.forward(1)
        a += -6
    turtle.right(1)

Et voici le résultat:

Réalisation du triangle et du faisceaux lumineux entrant

Création de l’arc en ciel :

Ensuite, en partant d’un point situé sur la bordure droite du triangle, nous avons créé une boucle for permettant de réaliser les traits de couleur à droite, définis par une liste. Pour que les couleurs attendus soient identiques à celle de la pochette d’album originale, nous avons trouvé leur équivalent en hexadécimal grâce au site « Image Color Picker ».

liste = ["#6f597a","#3476b2","#78ab23", "#f9fc49","#e8b30d","#de2b05",]
goto(63 - 10/6, 81)
turtle.right(12)
turtle.pensize(10)
s=5
for i in range(6):
    turtle.color(liste[i%6])
    pendown()
    turtle.forward(355 + 0.1*i)
    penup()
    goto(58 - 10/6*i, 80 + s + 4*i)
    turtle.left(1)
    s+=-1
Script initial avec ajout de l’arc en ciel

Enfin, nous avons reproduit les commandes de lecture, situées dans la partie inferieure de notre rendu visuel, en utilisant encore une fois des boucles for pour créer des formes géométriques telles que des rectangles ou des triangles.

Afin de créer un effet visuel plus esthétique nous avons aussi intégré les fonctions begin_fill() et end_fill() qui permettent de colorer l’intérieur de formes géométriques telles que le « bouton pause » par exemple.

Nous vous proposons la découverte de notre rendu final ci-dessous, j’espère qu’il vous plaira!

Rendu final du script après exécution

Télécharger le .py :

Pour finir, nous vous partageons l’intégralité de notre projet afin que vous puissiez le découvrir plus en détail !

PROJETTélécharger
Art

Astronomie : Le Seigneur des Anneaux … d’Uranus

Dans cet article, nous allons vous présenter notre projet sur Uranus, la septième planète du système solaire, que nous avons réalisée grâce au module turtle de python. Pour rédiger le script, nous avons notamment utilisé des fonctions, boucles et instructions conditionnelles.

Présentation et début du projet

La réalisation de ce projet s’inscrit dans le cadre de la 5ème édition du dispositif « Regard de géomètre ». Nos enseignants nous ont donc demandé de réaliser un script en python sur un thème parmi plusieurs qu’ils avaient sélectionnés. Nous avons choisi de faire notre projet sur le thème « Astronomie » car celui-ci nous a aussitôt inspirés. De plus, nous avons une passion commune pour l’astronomie. L’idée nous est donc venue de dessiner la planète Uranus ainsi que ses anneaux (eh oui Uranus possède des anneaux même si ceux-ci sont beaucoup moins imposants que ceux de Saturne 😁) grâce au module turtle de python.

  • Mais avant de coder Uranus, nous avons voulu rajouter un fond noir (le fond d’écran est blanc par défaut) pour symboliser l’espace. Afin de réaliser le fond noir, nous avons augmenté la taille du stylo grace à la fonction pensize() donc en le mettant à une taille égale à 10000. Ensuite nous avons choisi les coordonnées (x, y) du point vers lequel doit se déplacer la tortue (stylo = tortue) : on utilise donc goto(x, y). De plus, il est inutile de préciser la couleur puisque dans ce cas la couleur par défaut est le noir soit exactement la couleur que nous souhaitons obtenir. Enfin, une fois le fond noir réalisé, on réduit la taille du stylo pour que celui-ci ne soit pas trop grand lors de l’exécutions des fonctions suivantes.
  • Ce qui donne le code suivant :
pensize(10000)
goto(100,1)
pensize(5)
  • Ensuite, une fois que le fond noir est codé, il faut passer à la planète Uranus.
  • Dans un premier temps, nous décidons de la dessiner à l’aide de disques dont on augmentera le rayon successivement avec la boucle for i in range(). Mais, chaque fois qu’un disque apparaîtra, il effacera le précédent. Cela n’aurait guère d’importance si nous n’avions pas eu l’idée de faire des disques de couleurs différentes. Ainsi, la couleur finale d’Uranus est celle du dernier disque formé et la planète n’en est pas vraiment une.
  • Nous nous sommes donc rabattus sur les cercles afin de réaliser Uranus. Puis, à force de réfléchir sur le problème et avec un peu de recul, nous avons décidé de partir d’un cercle de rayon 0 puis d’augmenter ce rayon de la valeur de la variable t. En répétant cette action un grand nombre de fois (ici 220 fois) et en faisant en même temps un dégradé de couleur (en réduisant ou en augmentant les valeurs du Rouge et/ou du Vert et/ou du Bleu du code RVB de la couleur initiale par t) on obtient Uranus !
  • Le code python ci-dessous est l’application de ce que nous venons de dire précédemment. Nous allons cependant préciser quelques éléments :
    • Pour définir la fonction uranus, on doit rentrer la valeur du rayon, des coordonnées x et y du point de départ ainsi que définir la couleur du cercle.
    • Ces éléments sont définis après dans la boucle for t in range(220), ainsi que la valeur de la variable t, avant de les définir. Cela permet à la fonction de tracer des cercles de rayons de plus en plus grands.
    • Les éléments présents en dessous de def uranus permettent de positionner la tortue de façon à tracer un cercle.
    • Si vous souhaitez changer la couleur de la planète, vous avez la possibilité de faire un dégradé bleu en remplaçant les valeurs de color = (254 - t, 12 + t, 1 + t) par : color = (40, 221-t, 255).
def uranus(rayon, x, y, couleur=(1, 1, 1)):
    penup()
    goto(x, y)
    pendown()
    pencolor(couleur)
    circle(rayon)

t = 1
for t in range(220):
    x, y = 50,-200
    radius = 0 + t
    color = (254 - t, 12 + t, 1 + t)
    uranus(radius, x, y, color)

Et voici le résultat (fond noir + fonction uranus) :

Améliorations du projet

Une fois la planète obtenue sur fond noir nous contemplons de manière enthousiaste notre travail. Mais il nous reste toujours les anneaux à faire ! Et c’est là que ça se complique.

  • Pour les anneaux, nous pensions tout d’abord à les faire avec des cercles. Après plusieurs tentatives, il faut se rendre à l’évidence : les anneaux avec les cercles ça ne marche pas ! C’est à ce moment-là que l’un d’entre nous se souvient de la présence, sur la calculatrice NumWorks, dans la rubrique « Fonction », d’une fonction appelée « conique » qui trace des ellipses. La forme de l’ellipse nous semblant similaire à celle des anneaux, nous décidons donc de tracer des ellipses pour les anneaux. Comme nous ne savons pas comment coder une ellipse avec le module turtle de python, nous faisons une recherche sur Internet. Nous tombons alors sur une fonction très simple permettant de tracer une ellipse. Nous l’ajoutons alors au script.
  • Puis, nous remanions le script trouvé sur Internet en reprenant les mêmes principes utilisés précédemment dans la fonction uranus c’est-à-dire en augmentant progressivement la taille du rayon et en faisant un dégradé de couleurs. Pour définir la couleur, nous avons utilisé pencolor() afin que la couleur des anneaux soit autre que noir. Puis nous avons aussi rajouté pensize(5) avant for j in range(30) pour augmenter la taille du tracé. Enfin nous avons changé la valeur de seth() afin que les anneaux soient inclinés vers le bas droit de l’image, ainsi que la valeur de la fonction anneaux() dans le but que ceux-ci soient assez grands pour que la planète se situe bien au milieu.
  • Et comme d’habitude ne pas oublier de définir la variable avant son utilisation (sinon ça ne marche pas😉). Ci-dessous le code python des anneaux ainsi qu’Uranus + ses anneaux.
# Source: https://stacklima.com/dessiner-une-ellipse-a-laide-de-turtle-en-python/
j = 1
def anneaux(rad):
  pensize(5)
  for j in range(30):
    pencolor(255- 5*j, 255- 5*j, 255- 5*j)
    circle(rad + j,90)
    circle(rad//2 + j,90)

seth(-80) 
anneaux(290)

Arrivés à ce stade-là, on aurait pu arrêter. On avait la planète Uranus, ses anneaux et le fond noir. Mais l’image semblait un peu vide, on a donc eu l’idée de rajouter quelque chose en fond d’écran : des étoiles.

  • Pour dessiner les étoiles, c’est assez facile. Si on veut dessiner une étoile à 5 branches on peut dessiner une partie de l’étoile et répéter cette action cinq fois. Tout ceci en utilisant (encore) une fonction, dans laquelle on doit définir la longueur d’un trait, les coordonnées (x, y) du point de départ ainsi que la couleur de l’étoile. Avant de coder la fonction on met la taille du stylo à 5 avec pensize(5) pour remplir l’interieur de l’étoile (il est inutile de le préciser avant puisqu’on l’a déjà mis dans le code du fond noir qui est situé avant la fonction etoiles). On choisit aussi de préférence une longueur assez basse (mais pas trop quand même). 4 est un bon chiffre par exemple.
  • La boucle for i in range(5) permet de dessiner 5 fois deux demi-branches d’étoiles pour obtenir une étoile (il faut faire attention aux mesures d’angles et si l’on tourne à droite ou à gauche). La boucle for i range(210) permet de dessiner 210 étoiles. Dans cette boucle, on définit les coordonnées (x, y) ainsi que la couleur de l’étoile grâce au module randint. Celui-ci permet, pour chaque étoile, de définir des coordonnées aléatoires comprises entre -800 et 800 pour x et -400 et 400 pour y. C’est le même principe pour les couleurs à part que l’on a réduit l’écart entre les nombres pour obtenir comme couleur (toujours de manière aléatoire) du jaune, de l’orange ou des couleurs s’en rapprochant de très près.

Le code python des étoiles :

def etoiles(longueur, x, y, couleur=(1, 1, 1)):
    penup()
    goto(x, y)
    pendown()
    pencolor(couleur)
    for i in range(5):
        forward(longueur)
        left(74.2)
        forward(longueur)
        right(146)

for i in range(210):
    x, y = randint(-800, 800), randint(-400, 400)
    longueur = 4
    color = (randint(247, 255), randint(127, 255), randint(0, 12)) 
    etoiles(longueur, x, y, color)

Et le résultat :

Finalisation du projet

Enfin, nous avons pensé à rajouter le plus grand satellite naturel d’Uranus, Titania (à ne pas confondre avec Titan qui lui est le plus grand satellite naturel de Saturne).

  • On s’est dit que rajouter un petit détail supplémentaire pourrait être intéressant. On a tout de suite pensé à rajouter son plus grand satellite naturel. Pour le faire, on a utilisé le même procédé que pour Uranus, à savoir des cercles qui augmentent progressivement de rayon et un dégradé de couleurs. Mais cette fois-ci, pour plus d’originalité, nous avons utilisé des instructions conditionnelles pour faire le dégradé de couleur en fonction de la taille des cercles.
  • On utilise une boucle while cette fois-ci (on aurait pu aussi utiliser une boucle for comme dans les autres fonctions et vice versa). Ici on prend radius (le rayon du cercle) comme variable puis on l’augmente de 1 (avec +=) jusqu’à ce que radius soit égal à 30 : le principe reste donc le même qu’avec une boucle for.
  • Puis, dans la boucle while, on utilise des instructions conditionnelles afin que les cercles soit d’une certaine couleur en fonction de leur taille. Ainsi, la première condition (if) s’applique aux cercles dont le rayon est inférieur ou égal à 28 et dont la couleur sera du marron très clair. La deuxième condition (elif) concerne les cercles ayant un rayon compris entre 28 (non inclus) et 29 (inclus) : la couleur du cercle sera marron clair. A noter que l’on aurait pu remplacer elif radius > 28 and radius <= 29: par elif radius == 29: . Enfin, la troisième et dernière condition (else) concerne tous les cercles dont le rayon va jusqu’à 30 (mais ne concerne pas ceux des précédentes conditions), qui auront donc un couleur marron.
  • Le code et l’image obtenus :
def titania(rayon, x, y, couleur=(1, 1, 1)):
    penup()
    goto(x, y)
    pendown()
    pencolor(couleur)
    circle(rayon)
    
x, y = -200, 100
radius = 0
while radius <= 30:
    radius += 1
    if radius <= 28:
        color = (167-2, 103-2, 38-1)
    elif radius > 28 and radius <= 29:
        color = (136-2, 66-2, 29)   
    else :
        color = (91-2, 60-2, 17)
    titania(radius, x, y, color)

Au cours de la rédaction de notre script python, nous avons rencontré différents problèmes que nous avons essayé de résoudre.

  • Le problème majeur que nous avons rencontré est le décalage des anneaux et de la planète sur l’image quand d’autres fonctions étaient exécutées avant. De plus, comme la même variable i était utilisée pour chaque fonction cela créait des confusions de même que le positionnement des objets sur l’image. Nous avons donc changé le nom des variables afin que chacune est un nom différent (i, j, t et radius) ce qui explique le nom des variables précédentes. Nous avons aussi ajouté les lignes suivantes entre chaque fonction afin d’éviter toutes confusions et pour remettre les fonctions à jour :
penup()
goto(0,0)
pendown()
  • Nous avons aussi eu des problèmes avec la fonction titania, notamment avec le cercle marron qui se décalait trop vers le haut. Nous avons donc réduit l’intervalle dans lequel il était appliqué pour supprimer ce décalage. Nous avons rencontré d’autres problèmes minimes et sans importance notamment sur les valeurs et la précision de celles-ci, qui peuvent faire varier le rendu.

L’image finale

Voici donc le résultat final ci-dessous une fois que tous les éléments ont été assemblés et les problèmes réglés :

Télécharger le .py

Si vous désirez le télécharger (il en format compressé il faudra donc le décompresser😉). Le script contient un code python permettant de générer une image ainsi que les fonctions permettant de dessiner le fond noir, les étoiles, les anneaux, Uranus et Titania (dans l’ordre) :

Projet_NSI_sur_UranusTélécharger
Art

Astronomie : La carte du ciel

Depuis la nuit des temps, l’Homme est fasciné par ce qu’il se trouve au-dessus de sa tête à tel point qu’il a créé des cartes pour répertorier ces astres lumineux. Cette fascination pour l’inconnu a perduré au fil des siècles et, grâce aux cartes du ciel, les aventuriers d’hier, d’aujourd’hui et de demain on réussit à se repérer dans l’espace et surtout à rêver comme nous le montre James Michener dans La course aux étoiles.

-Prisonnier ?
-Oui. Les étoiles peu à peu vous happent. Elles vous font changer de perspective, d’une façon radical
Il lui tendit la carte avec respect et lui demanda :
« Avez-vous jamais vus les étoiles ? »

La course aux étoiles, p. 76

Genèse de l’idée

Lors de l’explication du projet, nous avons réfléchi et nous avons tout de suite pensé au domaine de l’astronomie. Au début nous avons pensé que faire une représentation en Pixel Art serait une bonne idée mais après de longues réflexions nous sommes revenus aux bases de l’astronomie et nous avons eu notre idée actuelle ; une carte du ciel de l’hémisphère Nord. C’est ainsi que notre projet a pu débuter…

Développement

Pour commencer nous avions besoin d’un fond dégradé du bleu au noir pour représenter notre beau ciel étoilé. De ce fait nous avons dû chercher comment le réaliser et nous avons trouvé un exemple de code sur Internet et nous avons pu l’adapter à notre manière.

Fond dégradé issu de notre script

Une fois le fond terminé et opérationnel, nous nous sommes concentrés sur la création des étoiles qui composeront notre carte. Ainsi, nous avons défini 3 types d’étoiles :

Les petites étoiles :

def etoilep():
    pensize(1)
    pencolor("white")
    for i in range(150):
        penup()
        x,y = randint(-640,640), randint(-360,360)
        goto(x,y)
        pendown()
        circle(1)

Nous avons positionné les petites étoiles de façon aléatoire grâce à un module python nommé random permettant un meilleur rendu visuel puisqu’elles servent à définir les étoiles les plus lointaines et donc visibles seulement par la NASA, l’ESA et également visibles dans les films de science-fiction tel H2G2.

Les étoiles moyennes : 

def etoilen():
    pendown()
    pensize(2)
    pencolor("yellow")
    for i in range(5):
        right(30)
        forward(2)
        right(120)
        forward(2)
        left(78)

Celles-ci servent à constituer les étoiles formant les constellations visibles dans notre hémisphère et donc forment les différentes constellations.

L’étoile polaire :

def etoilepolaire():
    pendown()
    pensize(2)
    pencolor("yellow")
    for i in range(5):
        right(30)
        forward(2)
        right(120)
        forward(2)
        left(78)

L’étoile polaire est une étoile particulière. En effet, sa position dans l’espace ne varie pas et indique globalement le nord. Elle servait notamment aux marins pour se repérer en pleine mer. C’est pour ça que nous l’avons défini aux coordonnées (0 , 0).

Rendu final du script après exécution

Maintenant que nous avons toutes nos étoiles, il faut les positionner !

Donc, pour ce faire, nous avons utilisé une carte du ciel en notre possession et nous avons mesuré à la règle la distance des étoiles par rapport à l’étoile polaire en essayant de les mettre à une certaine échelle pour ne pas sortir du cadre imposé.

Une fois toutes les mesures prises, nous avons créé deux listes, une première avec toutes les coordonnées x (horizontales) et une deuxième avec tous les coordonnés y (verticales) des étoiles formant les constellations. Pour séparer les constellations entre elles nous avons utilisé le mot-clé « None » .

Cependant, celui-ci nous a posé quelques problèmes. En effet, nous avions tout d’abord mis les « None » entre parenthèses (ne nous demandez pas pourquoi on a fait ça, on ne le sait pas nous-mêmes), ce qui nous a posé des problèmes. Après s’être rendu compte de cette erreur, un autre problème est apparu ! Mais nous avons pu la parer puisqu’il suffisait de mettre une condition à ce « None » . S’il apparait on passe au nombre suivant de la liste et s’il n’y est pas on trace !

En parlant de problèmes, nous en avons eu un autre, l’échelle des constellations. En effet, nous nous y sommes pris à trois fois pour avoir la bonne taille, d’abord trop petite, ensuite trop grande, mais à coups mathématiques très compliqués, nous avons réussi à trouver la bonne échelle !

Conclusion

Malgré les quelques difficultés rencontrées nous avons réussi à modéliser, assez grossièrement, nous devons l’admettre, une carte du ciel. Néanmoins, cette esquisse ravira sans aucun doute les amateurs d’astronomie pour sa beauté graphique et les informations données, malgré son imprécision elle reste tout de même assez juste et véridique. Notre projet se prête bien au thème de l’astronomie et nous en sommes fières. Cependant , il peut bien évidemment être amélioré avec un script plus optimisé et un peu plus de constellations.

Et puis, comme disait Léonard de Vinci, Celui qui s’oriente sur l’étoile ne se retourne pas.

Télécharger le .py

Projet Carte du ciel Thibault V. Samuel V. et Mathis LTélécharger

L’image finale