Tutoriel : Traitement d’images avec Python et Pillow

Pillow est une bibliothèque Python très populaire qui permet de manipuler facilement des images. Dans ce tutoriel, nous allons explorer différentes fonctionnalités de Pillow pour charger, modifier et sauvegarder des images.

Installation

Pour commencer, assurez-vous d’avoir Python installé sur votre système. Vous pouvez télécharger la dernière version sur Python.org.

Ensuite, installez la bibliothèque Pillow en utilisant pip, le gestionnaire de packages de Python :

pip install Pillow

Charger une image

Commençons par charger une image existante. Vous pouvez utiliser n’importe quelle image au format pris en charge (PNG, JPEG, GIF, etc.).

from PIL import Image

# Charger l'image
image = Image.open("exemple.jpg")

# Afficher l'image
image.show()

Modifier une image

Pillow offre une grande variété de méthodes pour modifier les images. Voici quelques exemples courants :

Redimensionner une image

# Redimensionner l'image à une taille spécifique
largeur = 400
hauteur = 300
image_redimensionnee = image.resize((largeur, hauteur))

# Afficher l'image redimensionnée
image_redimensionnee.show()

Convertir une image en niveaux de gris

image_niveaux_de_gris = image.convert('L')
image_niveaux_de_gris.show()

Appliquer des filtres

from PIL import ImageFilter

# Appliquer un filtre de flou gaussien
image_flou = image.filter(ImageFilter.GaussianBlur(radius=2))
image_flou.show()

Faire pivoter une image

# Faire pivoter l'image de 90 degrés dans le sens des aiguilles d'une montre
image_pivot = image.rotate(90)
image_pivot.show()

Sauvegarder une image modifiée

Une fois que vous avez apporté les modifications souhaitées à votre image, vous pouvez les sauvegarder dans un nouveau fichier.

# Sauvegarder l'image modifiée
image_redimensionnee.save("nouvelle_image.jpg")

Voici quelques exemples plus avancés de traitement d’images avec Pillow :

1. Segmenter une image avec la méthode de clustering K-Means

from PIL import Image
import numpy as np
from sklearn.cluster import KMeans

# Charger l'image
image = Image.open("exemple.jpg")

# Convertir l'image en tableau numpy
image_array = np.array(image)

# Appliquer la méthode de clustering K-Means pour segmenter l'image en 5 couleurs
kmeans = KMeans(n_clusters=5)
kmeans.fit(image_array.reshape(-1, 3))
colors = kmeans.cluster_centers_.astype(int)
labels = kmeans.labels_
segmented_image = colors[labels].reshape(image_array.shape).astype(np.uint8)

# Afficher l'image segmentée
Image.fromarray(segmented_image).show()

2. Appliquer une transformation de perspective

from PIL import Image
import numpy as np

# Charger l'image
image = Image.open("exemple.jpg")

# Définir les coins de l'image d'origine
points_origine = np.array([[0, 0], [image.width, 0], [image.width, image.height], [0, image.height]])

# Définir les nouveaux coins après la transformation
nouveau_points = np.array([[50, 50], [image.width - 100, 100], [image.width, image.height - 50], [100, image.height - 100]])

# Calculer la matrice de transformation
matrice_transformation = cv2.getPerspectiveTransform(points_origine.astype(np.float32), nouveau_points.astype(np.float32))

# Appliquer la transformation à l'image
image_transformee = cv2.warpPerspective(np.array(image), matrice_transformation, (image.width, image.height))

# Afficher l'image transformée
Image.fromarray(image_transformee).show()

3. Détection de visages avec OpenCV et superposition de rectangles

import cv2

# Charger l'image en niveaux de gris
image_gris = cv2.cvtColor(cv2.imread("exemple.jpg"), cv2.COLOR_BGR2GRAY)

# Charger le classificateur de visage pré-entraîné
classificateur_visage = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")

# Détecter les visages dans l'image
visages = classificateur_visage.detectMultiScale(image_gris, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

# Dessiner des rectangles autour des visages détectés
image_visages = cv2.imread("exemple.jpg")
for (x, y, w, h) in visages:
    cv2.rectangle(image_visages, (x, y), (x+w, y+h), (255, 0, 0), 2)

# Afficher l'image avec les visages détectés
Image.fromarray(image_visages).show()

Ces exemples illustrent quelques tâches plus avancées que vous pouvez réaliser avec Pillow en combinaison avec d’autres bibliothèques comme NumPy et OpenCV. Vous pouvez les utiliser comme point de départ pour explorer davantage le traitement d’images et créer des applications plus sophistiquées.

Voici quelques cas particuliers de traitement d’images avec Pillow :

1. Conversion d’une image en ASCII art

from PIL import Image

# Définir une chaîne de caractères représentant différentes nuances de gris
ascii_chars = "@%#*+=-:. "

# Charger l'image en niveaux de gris
image = Image.open("exemple.jpg").convert("L")

# Redimensionner l'image pour correspondre à la taille souhaitée pour l'ASCII art
largeur, hauteur = image.size
largeur_redimensionnee = 100
rapport_aspect = hauteur / float(largeur)
hauteur_redimensionnee = int(largeur_redimensionnee * rapport_aspect)
image = image.resize((largeur_redimensionnee, hauteur_redimensionnee))

# Convertir chaque pixel en caractère ASCII
ascii_art = ""
pixels = image.load()
for y in range(hauteur_redimensionnee):
    for x in range(largeur_redimensionnee):
        pixel = pixels[x, y]
        indice_char = pixel // 25  # Convertir la valeur de pixel (0-255) en un indice pour ascii_chars
        ascii_art += ascii_chars[indice_char]
    ascii_art += "\n"

# Afficher l'ASCII art
print(ascii_art)

2. Création d’une mosaïque d’images

from PIL import Image

# Charger les images
image1 = Image.open("image1.jpg")
image2 = Image.open("image2.jpg")

# Définir la taille de la mosaïque
largeur, hauteur = 800, 600

# Redimensionner les images pour qu'elles correspondent à la taille de la mosaïque
image1 = image1.resize((largeur // 2, hauteur))
image2 = image2.resize((largeur // 2, hauteur))

# Créer une nouvelle image pour la mosaïque
mosaique = Image.new("RGB", (largeur, hauteur))

# Placer les images dans la mosaïque
mosaique.paste(image1, (0, 0))
mosaique.paste(image2, (largeur // 2, 0))

# Afficher la mosaïque
mosaique.show()

3. Création d’une image avec des motifs répétés

from PIL import Image, ImageDraw

# Créer une nouvelle image
largeur, hauteur = 400, 400
image = Image.new("RGB", (largeur, hauteur), "white")

# Dessiner des motifs répétés
taille_motif = 20
draw = ImageDraw.Draw(image)
for x in range(0, largeur, taille_motif):
    for y in range(0, hauteur, taille_motif):
        if (x + y) % (taille_motif * 2) == 0:
            draw.rectangle([x, y, x + taille_motif, y + taille_motif], fill="black")

# Afficher l'image avec les motifs répétés
image.show()

Ces cas particuliers montrent quelques exemples uniques de ce que vous pouvez faire avec Pillow en dehors des opérations de traitement d’images standard. Vous pouvez expérimenter avec ces idées et les adapter à vos propres projets pour créer des effets visuels intéressants et des applications créatives.

Conclusion

Pillow est une bibliothèque puissante et flexible pour le traitement d’images en Python. Ce tutoriel a couvert les bases pour charger, modifier et sauvegarder des images, mais il existe de nombreuses autres fonctionnalités à découvrir. N’hésitez pas à explorer la documentation de Pillow pour en savoir plus sur ses capacités étendues.