NumPy pour le traitement d’images – KDnuggets

combination-facial-features-concept NumPy pour le traitement d'images - KDnuggets NEWS

NumPy est un outil puissant pour le traitement d’images en Python. Il permet de manipuler des images à l’aide d’opérations matricielles. Cet article explore plusieurs techniques de traitement d’images utilisant NumPy.

Importation de bibliothèques

Pour commencer, importons les bibliothèques nécessaires : PIL, NumPy et Matplotlib. PIL est utilisé pour ouvrir des images, NumPy pour les opérations de tableau et le traitement d’image efficace, et Matplotlib pour la visualisation des images.

import numpy as np

from PIL import Image

import matplotlib.pyplot as plt

Recadrer l’image

Définissons les coordonnées pour marquer la zone que nous voulons recadrer de l’image. La nouvelle image contiendra uniquement la partie sélectionnée.

# Charger l'image avec PIL

img = Image.open('cat.jpg')



# Convertir l'image en tableau NumPy

img_array = np.array(img)



# Définir les coordonnées de recadrage

y1, x1 = 1000, 1000  # Coin supérieur gauche du ROI

y2, x2 = 2500, 2000  # Coin inférieur droit du ROI

cropped_img = img_array[y1:y2, x1:x2]



# Afficher l'image originale et l'image recadrée

plt.figure(figsize=(10, 5))



# Afficher l'image originale

plt.subplot(1, 2, 1)

plt.imshow(img_array)

plt.title('Image originale')

plt.axis('off')



# Afficher l'image recadrée

plt.subplot(1, 2, 2)

plt.imshow(cropped_img)

plt.title('Image recadrée')

plt.axis('off')



plt.tight_layout()

plt.show()

Faire pivoter l’image

Nous faisons pivoter l’image de 90 degrés dans le sens inverse des aiguilles d’une montre à l’aide de la fonction ‘rot90’ de NumPy.

# Charger l'image avec PIL

img = Image.open('cat.jpg')



# Convertir l'image en tableau NumPy

img_array = np.array(img)



# Faire pivoter l'image de 90 degrés dans le sens inverse des aiguilles d'une montre

rotated_img = np.rot90(img_array)



# Afficher l'image originale et l'image pivotée

plt.figure(figsize=(10, 5))



# Afficher l'image originale

plt.subplot(1, 2, 1)

plt.imshow(img_array)

plt.title('Image originale')

plt.axis('off')



# Afficher l'image pivotée

plt.subplot(1, 2, 2)

plt.imshow(rotated_img)

plt.title('Image pivotée (90 degrés)')

plt.axis('off')



plt.tight_layout()

plt.show()

Retourner l’image

Nous utilisons la fonction ‘fliplr’ de NumPy pour retourner l’image horizontalement.

# Charger l'image avec PIL

img = Image.open('cat.jpg')



# Convertir l'image en tableau NumPy

img_array = np.array(img)



# Retourner l'image horizontalement

flipped_img = np.fliplr(img_array)



# Afficher l'image originale et l'image retournée

plt.figure(figsize=(10, 5))



# Afficher l'image originale

plt.subplot(1, 2, 1)

plt.imshow(img_array)

plt.title('Image originale')

plt.axis('off')



# Afficher l'image retournée

plt.subplot(1, 2, 2)

plt.imshow(flipped_img)

plt.title('Image retournée')

plt.axis('off')



plt.tight_layout()

plt.show()

Négatif d’une image

Le négatif d’une image est réalisé en inversant ses valeurs de pixels. Pour les images en niveaux de gris, chaque pixel est soustrait du maximum (255 pour les images 8 bits). Pour les images couleur, cela est effectué séparément pour chaque canal de couleur.

# Charger l'image avec PIL

img = Image.open('cat.jpg')



# Convertir l'image en tableau NumPy

img_array = np.array(img)



# Vérifier si l'image est en niveaux de gris ou en RGB

is_grayscale = len(img_array.shape) < 3



# Fonction pour créer le négatif d'une image

def create_negative(image):

    if is_grayscale:

        # Pour les images en niveaux de gris

        negative_image = 255 - image

    else:

        # Pour les images couleur (RGB)

        negative_image = 255 - image

    return negative_image



# Créer le négatif de l'image

negative_img = create_negative(img_array)



# Afficher l'image originale et l'image négative

plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)

plt.imshow(img_array)

plt.title('Image originale')

plt.axis('off')



plt.subplot(1, 2, 2)

plt.imshow(negative_img)

plt.title('Image négative')

plt.axis('off')



plt.tight_layout()

plt.show()

Binariser l’image

La binarisation d’une image la convertit en noir et blanc. Chaque pixel est marqué en noir ou en blanc en fonction d’une valeur seuil. Les pixels inférieurs au seuil deviennent 0 (noir) et ceux au-dessus deviennent 255 (blanc).

# Charger l'image avec PIL

img = Image.open('cat.jpg')



# Convertir l'image en niveaux de gris

img_gray = img.convert('L')



# Convertir l'image en niveaux de gris en tableau NumPy

img_array = np.array(img_gray)



# Binariser l'image en utilisant un seuil

threshold = 128

binary_img = np.where(img_array < threshold, 0, 255).astype(np.uint8)



# Afficher l'image originale en niveaux de gris et l'image binaire

plt.figure(figsize=(10, 5))



plt.subplot(1, 2, 1)

plt.imshow(img_array, cmap='gray')

plt.title('Image originale en niveaux de gris')

plt.axis('off')



plt.subplot(1, 2, 2)

plt.imshow(binary_img, cmap='gray')

plt.title('Image binaire (Seuil = 128)')

plt.axis('off')



plt.tight_layout()

plt.show()

Conversion de l’espace colorimétrique

La conversion de l’espace colorimétrique change une image d’un modèle de couleur à un autre. Cela se fait en modifiant le tableau de valeurs de pixels. Nous utilisons une somme pondérée des canaux RVB pour convertir une image couleur en niveaux de gris.

# Charger l'image avec PIL

img = Image.open('cat.jpg')



# Convertir l'image en tableau NumPy

img_array = np.array(img)



# Formule de conversion en niveaux de gris : Y = 0.299*R + 0.587*G + 0.114*B

gray_img = np.dot(img_array[..., :3], [0.299, 0.587, 0.114])



# Afficher l'image RGB originale et l'image en niveaux de gris

plt.figure(figsize=(10, 5))



plt.subplot(1, 2, 1)

plt.imshow(img_array)

plt.title('Image RGB originale')

plt.axis('off')



plt.subplot(1, 2, 2)

plt.imshow(gray_img, cmap='gray')

plt.title('Image en niveaux de gris')

plt.axis('off')



plt.tight_layout()

plt.show()

Histogramme d’intensité des pixels

L’histogramme montre la distribution des valeurs de pixels dans une image. L’image est aplatie dans un tableau unidimensionnel pour calculer l’histogramme.

# Charger l'image avec PIL

img = Image.open('cat.jpg')



# Convertir l'image en tableau NumPy

img_array = np.array(img)



# Calculer l'histogramme de l'image

hist, bins = np.histogram(img_array.flatten(), bins=256, range=(0, 256))



# Tracer l'histogramme

plt.figure(figsize=(10, 5))

plt.hist(img_array.flatten(), bins=256, range=(0, 256), density=True, color="gray")

plt.xlabel('Intensité des pixels')

plt.ylabel('Fréquence normalisée')

plt.title('Histogramme de l'image en niveaux de gris')

plt.grid(True)

plt.show()

Image de masquage

Masquer une image signifie afficher ou masquer des parties en fonction de règles. Les pixels marqués 1 sont conservés tandis que les pixels marqués 0 sont masqués.

# Charger l'image avec PIL

img = Image.open('cat.jpg')



# Convertir l'image en tableau NumPy

img_array = np.array(img)



# Créer un masque binaire

mask = np.zeros_like(img_array[:, :, 0], dtype=np.uint8)

center = (img_array.shape[0] // 2, img_array.shape[1] // 2)

radius = min(img_array.shape[0], img_array.shape[1]) // 2  # Augmenter le rayon pour un cercle plus grand

rr, cc = np.meshgrid(np.arange(img_array.shape[0]), np.arange(img_array.shape[1]), indexing='ij')

circle_mask = (rr - center[0]) ** 2 + (cc - center[1]) ** 2 < radius ** 2

mask[circle_mask] = 1



# Appliquer le masque à l'image

masked_img = img_array.copy()

for i in range(img_array.shape[2]):  # Appliquer à chaque canal de couleur

    masked_img[:, :, i] = img_array[:, :, i] * mask



# Afficher l'image originale et l'image masquée

plt.figure(figsize=(10, 5))



plt.subplot(1, 2, 1)

plt.imshow(img_array)

plt.title('Image originale')

plt.axis('off')



plt.subplot(1, 2, 2)

plt.imshow(masked_img)

plt.title('Image masquée')

plt.axis('off')



plt.tight_layout()

plt.show()

Conclusion

Dans cet article, nous avons exploré différentes techniques de traitement d’images à l’aide de NumPy. Nous avons utilisé PIL, NumPy et Matplotlib pour recadrer, faire pivoter, retourner et binariser les images. De plus, nous avons appris à créer des négatifs d’images, à modifier les espaces colorimétriques, à créer des histogrammes et à appliquer des masques.

Jayita Gulati est une passionnée d’apprentissage automatique et une rédactrice technique motivée par sa passion pour la création de modèles d’apprentissage automatique. Elle est titulaire d’une maîtrise en informatique de l’Université de Liverpool.

Source