Générer des illustrations en Python inspirées de la peinture Million-Dollar Spots de Hirst

Vous êtes allé dans un musée d’art et vous vous demandez comment une œuvre d’art aussi ordinaire peut devenir si célèbre ou être vendue à un prix aussi élevé ? Ou comment des œuvres d’art qui semblent si faciles à réaliser avec des techniques aussi basiques peuvent-elles être si vénérées et attirer une grande foule d’enchérisseurs ? C’est le cas des peintures ponctuelles de Hirst.

Damien Hirst est un artiste anglais célèbre pour son art contemporain sur la vie, la mort et la beauté. Ses célèbres peintures ponctuelles comprennent des cercles remplis de différentes couleurs disposés sous forme de grille avec un fond de couleur claire. Ces peintures, bien que si claires et simples, ont été vendues aux enchères jusqu’à un million de dollars!

Dans cet article, nous utiliserons le module colorgramme et tortue de Python pour créer des peintures ponctuelles, en s’inspirant de la palette de couleurs et des techniques de Hirst. Il s’agit d’un didacticiel Python adapté aux débutants, mais nécessite une connaissance de base des principes fondamentaux de Python, ainsi que la création d’objets et l’utilisation de méthodes, ainsi que l’importation et l’utilisation de modules Python. Grâce à ce didacticiel Python amusant et intéressant, nous apprendrons à implémenter le concept de POO dans la programmation ainsi qu’à apprendre comment atteindre notre objectif en utilisant des modules et seulement quelques lignes de code.

Réveillons l’artiste qui sommeille en nous pendant que nous apprenons le codage Python !

Peintures ponctuelles

Les peintures ponctuelles de Hirst comprennent de petites taches de différentes couleurs alignées sous forme de grille. Les peintures sont uniques par leur nombre de points, ainsi que par la palette de couleurs utilisée dans ces peintures. Nous utiliserons le module colorgram de Python afin d’extraire la palette de couleurs de ces peintures tant vénérées, puis utiliserons le module tortue de Python pour dessiner ces taches sous forme de grille. Nous pouvons spécifier le nombre de points sur notre toile, ainsi que la distance entre eux et la palette de couleurs utilisée.

Pour référence, pensez à vérifier ces peintures via ce lien.

Extraction des couleurs

La première chose à faire est d’extraire une palette de couleurs d’un des tableaux de Hirst. Nous téléchargerons le tableau dans le même répertoire que le fichier Python dans lequel nous écrivons notre programme. Mais d’abord, installons le colorgram module en écrivant les lignes de commande suivantes dans le terminal :

pip install colorgram.py

Ensuite, nous allons import le module colorgram dans notre code et utilisez le extract fonction, tout en spécifiant le fichier image et le nombre de couleurs que nous voulons extraire de l’image de référence comme arguments de la fonction extract fonction. Ici est le fichier image que j’ai téléchargé sous le nom « ref.jpg » et que j’ai utilisé pour définir la palette de couleurs de ma peinture ponctuelle générée par Python.

import colorgram
colors = colorgram.extract("ref.jpg",20)
print(colors)

Lorsque nous exécutons les lignes de code ci-dessus, les 20 couleurs présentes dans l’image de référence seront imprimées :

Notez que les couleurs extraites ci-dessus sont dans un format différent de celui compatible avec le module tortue. Nous allons maintenant transformer ces couleurs en couleurs compatibles avec les tortues.

Création de la liste de couleurs

Tout d’abord, nous allons créer un vide list et ajoutez les couleurs extraites une par une après un formatage approprié au format RVB. Nous exploiterons chacune des valeurs r, g et b des couleurs extraites et les stockerons dans notre liste créée avec un formatage approprié. A cet effet, nous utiliserons le for boucle:

rgb_colors = []
for color in colors:
    r = color.rgb.r
    g = color.rgb.g
    b = color.rgb.b
    new_color = (r, g, b)
    rgb_colors.append(new_color)
print(rgb_colors)

Comme le montre l’image ci-dessus, les couleurs RVB ont été correctement formatées et peuvent désormais être utilisées à l’avance pour sélectionner aléatoirement les couleurs des points.

Importation de Turtle et configuration des paramètres de base

Maintenant, nous allons importer le module Python Turtle pour créer notre illustration. Nous allons définir les paramètres de base de notre tortue. Le premier est le colormode()qui décidera comment nous utiliserons les couleurs dans notre code à venir, soit entre 0 et 1, soit entre 0 et 255. Découvrez-en plus sur la fonction via ceci lien.

import turtle

turtle.colormode(255)
tim = Turtle()
tim.shape("turtle")
tim.color("coral")

Comme nous utilisons les couleurs RVB dans leur format 0-255, nous avons ajouté 255 comme argument. De plus, nous avons également créé l’objet tortue à partir du Turtle classe dans le module Python Turtle et l’a appelé tim, ainsi que personnalisé ses formes et sa couleur. Nous utiliserons cette tortue comme outil de dessin.

Positionner notre tortue

Maintenant que nous avons créé l’objet tortue, visualisons à l’aide de l’objet écran.

from turtle import Screen

screen = Screen()
screen.exitonclick()

Comme le montre l’image ci-dessus, la tortue est positionnée au milieu de l’écran. Nous avons besoin que la tortue soit dans un coin pour qu’elle commence à créer les points en ligne. Nous pouvons choisir le coin inférieur gauche comme point de départ, la tortue se déplaçant de gauche à droite puis vers le haut tout en dessinant les points.

Nous pouvons y parvenir avec la fonction tortue setheading() qui prend un angle comme paramètre pour définir la direction de la tortue, et après quelques essais et essais, nous savons que cela peut être fait en réglant l’angle à 225. Nous allons ensuite avancer d’une distance particulière, disons 300. Voici comment notre tortue se trouve maintenant en bas à gauche :

Nous allons à nouveau définir la direction dans laquelle la tortue se dirige sur 0, nous pouvons donc commencer par notre dessin de points.

Dessiner les points

Maintenant que la direction de notre tortue est définie, nous allons commencer à dessiner les points. Nous utiliserons celui de la tortue méthode par points, qui prend la taille du point et la couleur à remplir. Nous réaliserons ce dessin de points via la boucle for, en gardant à l’esprit le nombre total de points que nous voulons. Si nous voulons une grille de points de 10 x 10, le nombre total de points sera de 100. Après chaque 10ème point, la tortue doit remonter d’une ligne et continuer à dessiner les points. Nous utiliserons pour cela l’opération modulo. De plus, nous importerons et utiliserons le module aléatoire pour choisir aléatoirement une couleur pour chaque point.

Nous utiliserons le forward et setheading méthodes dans le for boucle pour créer les points en avançant, puis en remontant :

import random

number_of_dots = 100

for dot_count in range(1, number_of_dots + 1):
    tim.dot(20, random.choice(rgb_colors))
    tim.forward(50)
    if dot_count % 10 == 0:
        tim.setheading(90)
        tim.forward(50)
        tim.setheading(180)
        tim.forward(500)
        tim.setheading(0)

Cacher la tortue et les lignes

Une fois nos points créés, nous devons masquer la tortue et les lignes. Nous pouvons facilement le faire avec le hideturtle() et penup() méthodes.

tim.penup()
tim.hideturtle()

Voici à quoi ressemblera le résultat final une fois que nous aurons exécuté les lignes de code ci-dessus :

Conclusion

Comme on peut le voir ci-dessus, nous avons réussi à créer une magnifique œuvre d’art en suivant la technique des points de Hirst. Le module colorgram de Python nous a permis d’extraire une belle palette de couleurs, et le module tortue nous a aidé à créer l’illustration en utilisant cette palette. Ceci n’est qu’un exemple simple de la manière dont de si belles pièces peuvent être créées à l’aide de code et de ce qui se passe lorsque l’art et la programmation coïncident.