Étiquette : image

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
Art

Un rafale en AxiDraw

Il est parfois compliqué de se motiver pour travailler surtout en période de vacance scolaire. C’est pourquoi j’ai choisis lors de ce projet de NSI de mêler travail et passion en vous proposant un projet en lien avec l’aéronautique.

Fait de ta vie un rêve et de ton rêve une réalité.

Antoine de Saint-Exupéry

Naissance du projet :

Lorsque nos professeurs ont présenté les différentes possibilités parmi lesquelles nous pourrions réaliser notre projet, j’ai tout de suite pensé à utiliser l’ Axidraw et ce pour plusieurs raisons.

Tout d’abord, pour découvrir cette machine mais aussi pour les nombreuses possibilités d’utilisation que cette mécanique avait à m’offrir.

Ensuite, j’ai utilisé la maxime  » Il faut joindre l’utile à l’agréable » en choisissant d’utiliser ma passion, qui est celle de l’aéronautique, afin de pouvoir travailler sans regret durant les vacances.

C’ est ainsi que je me suis mis à coder un Rafale ( un célèbre avion de chasse Français ), en python !

Développement du projet

Pour commencer, il me fallait une image sur papier, une sorte de plan, de ce à quoi je voulais que mon Rafale ressemble, et ce tout en traits puisque l’Axidraw ne peut tracer de courbes.

Ma « feuille de route », une véritable œuvre d’art…

Mise en place

Une fois après avoir réalisé mon esquisse, il ne restait plus qu’à mettre à l’échelle mes différentes valeurs que je pouvais dès maintenant mesurer à la règle.

Ainsi, on obtenait :

  • 1cm sur la feuille en longueur -> 30 de longueur pour l’AXIDRAW
  • 1cm sur la feuille en largeur -> 36.5 de largeur pour l’AXIDRAW.

Ensuite, j’ai crée de nombreuses listes que j’ai ensuite appelé en utilisant les fonctions mises à notre disposition par nos professeurs de NSI :

percheravito = [[153,317.55], [141,295.65],[141,295.65], [117,292], [117,288.35], [147,292],[156,313.9]]
haut_aileron = [[759,193,45],[828,193.45],[804,175.2],[784.5,175.2]]
segments(percheravito)
polygone(haut_aileron)

Ainsi, dans l’exemple ci-dessus nous pouvons voir la liste permettant de faire la perche qui sert au ravitaillement en vol du rafale avec son appellation par la fonctions segments qui relie les points aux coordonnées x et y définis dans ma liste. L’appellation de la fonction polygone va elle rajouter un segment qui ira de mon premier point au dernier présent dans la liste haut_aileron afin de former un polygone.

Création des verrières du rafale.

Comme vous avez pu le voir dans mon esquisse de l’œuvre que je voulais produire, les verrières du rafale devaient être constellées de traits afin de donner un esthétique au rendu final mais aussi afin d’introduire quelques fonctions dans ma création.

Mais, je ne pouvais pas créer une seule et même fonction que j’appellerai pour les trois verrières puisque ces mêmes verrières étaient disposées à des endroits différents et séparés par l’armature de l’avion.

image des différentes verrières que je voulais remplir

Ainsi, j’ai du créer trois verrières :

Première verrière :

Pour cette première verrière, vu sa configuration, je n’avais pas besoin de créer un code trop important. En effet, une simple boucle for permettrait de répéter x fois en fonction du nombre de répétitions des segments, grâce à la fonctions segments fournie, en décalant x_depart, y_depart et y_arrivee à chaque répétition. Ainsi, nous obtenons ce code :

def trait(x_depart: float, y_depart: float, x_arrivee: float, y_arrivee: float, repetitions: int):
    for i in range(repetitions):
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 4.5
        y_depart -= 2.25
        y_arrivee -= 2.25

Seconde verrière :

Pour cette verrière, il n’était cette fois plus question de prendre une boucle for puisque si vous regardez bien elle se compose de deux parties. J’ai donc utilisé une succession de deux boucles while consécutives qui détermineraient les variations des points x et y en fonction des coordonnées d’arrivée des points de mes segments.

def traits(x_depart: float, y_depart: float, x_arrivee: float, y_arrivee: float, ):
    while x_depart >= 209 and y_depart >= 270:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart -= 1
        x_arrivee += 0.75
        y_depart -= 2.25
        y_arrivee -= 2.25

    while x_depart <= 255 and y_depart >= 273.75:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 6.5
        x_arrivee += 0.25
        y_depart -= 2.25
        y_arrivee -= 2.25

Troisième verrière :

Pour cette troisième verrière, j’ai réutilisé le code de ma seconde verrière en changeant les points x_depart, x_arrivee, y_depart, y_arrivee ainsi que les variations de ces points en fonction des boucles while ce qui nous donne :

def traittss(x_depart: float, y_depart: float, x_arrivee: float, y_arrivee: float):
    while x_arrivee <= 360 and y_arrivee >= 290.75:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 0.8
        x_arrivee += 1.2
        y_depart -= 2.25
        y_arrivee -= 2.25

    while y_depart >= 278:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 0.3
        x_arrivee -= 8
        y_depart -= 2.25
        y_arrivee -= 2.25

Compte rendu final des verrières :

Ainsi, après avoir appelé ces fonctions j’obtenais les verrières en image ci-dessous :

Néanmoins, comme vous vous en doutez surement, cette réalisation n’a pas été aussi facile que ce qu’il vous a été présenté puisque il a fallu calculer les variations des points x et tester différentes variations des points y afin d’obtenir le meilleur rendu visuel.

Création du réacteur :

Pour le réacteur, j’ai souhaité ajouter des segments de la même manière que pour mes verrières. J’ai donc repris le code utilisant les boucles while que j’ai développé puisqu’il ma fallu créer une troisième boucle while pour obtenir le rendu souhaité.

def react(x_depart: float, y_depart: float, x_arrivee: float, y_arrivee: float):
    while  y_arrivee >= 405.15:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 0
        x_arrivee += 10
        y_depart -= 5
        y_arrivee -= 5

    while y_arrivee >= 372:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 0
        x_arrivee += 0
        y_depart -= 5
        y_arrivee -= 5
        
    while y_arrivee >= 355.875:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart -= 0
        x_arrivee -= 10
        y_depart -= 5
        y_arrivee -= 5

L’exécution de ce code ma ensuite donné ce rendu :

Dernières finitions :

Maintenant que les parties complexes de mon code ont été réalisées, il ne me restait plus que deux choses à faire :

  • Positionner la fameuse cocarde tricolore ( qui sera unicolore sur mon rendu graphique car l’Axidraw ne prend pas en charge les couleurs ) sur mon rafale.
  • « Légender » mon œuvre en écrivant le nom de l’avion représenté en dessous.

Pour la cocarde, je n’eu qu’à utiliser la fonction cercle déjà donnée et en tracer deux consécutivement, avec le même centre mais avec le rayon du second cercle moitié moins grand que le rayon du premier cercle.

Pour légender le dessin obtenu, il ne me restait seulement qu’ à exécuter une succession de segments formant le mot RAFALE.

Conclusion :

Ainsi, ce projet m’a permis de normaliser mon utilisation des fonctions et des listes. Néanmoins, je pense que de nombreuses améliorations auraient pu être possible avec un peu plus de temps notamment en ajoutant des segments pour rendre mon image plus précise mais aussi en modifiant la bordure dessinée par l’Axidraw afin qu’elle mette plus en valeur le rafale représenté.

Mais je dois quand même ajouter que je suis fier de ce que j’ai déjà réalisé car jamais je ne me serais attendu à un rendu comme celui là en n’ utilisant que des segments !

Télécharger le .py :

rafaleTélécharger

L’image finale :

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