Traitement d'image Python: Flou, détection de bord et affinage

Le traitement d'image joue un rôle crucial dans de nombreuses applications, de la vision par ordinateur à l'imagerie médicale. Avec Python et ses bibliothèques puissantes, il devient accessible à tous d'implémenter des opérations complexes. Cet article vous guide à travers les techniques de base comme le flou d'image, la détection de bord et l'affinage, offrant des exemples pratiques et des explications claires pour améliorer vos compétences en traitement d'image.

Pourquoi utiliser le filtrage d'image ?

Le filtrage d'image est une étape fondamentale du traitement d'image. Il permet de modifier ou d'améliorer une image, en accentuant certaines caractéristiques ou en supprimant les détails indésirables. Le flou est utilisé pour réduire le bruit, la détection de bord pour mettre en évidence les contours, et l'affinage pour rendre les détails plus nets.

Ces opérations, bien que simples, constituent la base de techniques plus avancées. En Python, nous pouvons facilement les implémenter grâce à des bibliothèques comme NumPy, Matplotlib et SciPy. Ces outils offrent une flexibilité et une puissance remarquables pour manipuler et transformer des images selon nos besoins.

Configuration de l'environnement Python pour le traitement d'image

Avant de plonger dans le code, il est essentiel de configurer notre environnement Python.

Nous devons nous assurer d'avoir installé les bibliothèques nécessaires : NumPy pour le calcul numérique, Matplotlib pour l'affichage d'images, et SciPy pour les fonctions de traitement du signal. Vous pouvez installer ces bibliothèques à l'Aide de pip :

pip install numpy matplotlib scipy opencv-python

L'installation de OpenCV via opencv-python est cruciale car elle fournit des fonctions optimisées pour les opérations sur les images, y compris les conversions de couleur. Une fois l'environnement configuré, nous pouvons importer ces bibliothèques dans notre script Python et commencer à travailler sur nos images.

L'utilisation de ces bibliothèques est essentielle pour la manipulation des images dans le domaine de l'IA et de la science des données. La bibliothèque matplotlib est également très importante pour l'importation des bibliothèques numpy et pyplot.

Flou d'image

Le flou d'image, également appelé lissage, sert à réduire le bruit et à adoucir les détails d'une image. Nous allons utiliser un filtre de convolution pour cela.

Un filtre de convolution est une matrice qui est appliquée à chaque pixel de l'image, en calculant une moyenne pondérée des pixels voisins. Pour créer un filtre de flou, nous utilisons une matrice où tous les éléments sont égaux, de sorte que chaque pixel contribue de manière égale à la moyenne.

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
import cv2

def apply_blur(image, kernel_size):
    kernel = np.ones((kernel_size, kernel_size)) / (kernel_size ** 2)
    blurred_image = signal.convolve2d(image, kernel, mode='same', boundary='symm')
    return blurred_image

image = plt.imread('bird.png')
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

blurred = apply_blur(gray_image, kernel_size=5)

plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.imshow(gray_image, cmap='gray')
plt.title('Image Originale')

plt.subplot(1, 2, 2)
plt.imshow(blurred, cmap='gray')
plt.title('Image Floue')

plt.show()

Dans cet exemple, la fonction apply_blur prend une image et une taille de noyau comme arguments. Elle crée un noyau de convolution en divisant une matrice de uns par le carré de la taille du noyau, assurant ainsi que la somme des éléments du noyau est égale à 1. Ensuite, elle utilise la fonction convolve2d de SciPy pour appliquer le filtre à l'image, avec le mode 'same' pour conserver la taille de l'image et la condition aux limites 'symm' pour gérer les bords. On mentionne l'importance d'une conversion en niveau de gris afin d'avoir une gestion plus facile des couleurs. Cette technique peut être affinée en variant la taille du noyau pour obtenir différents degrés de flou.

Détection de Bord

La détection de bord est une technique essentielle pour identifier les contours et les structures dans une image. Un des opérateurs les plus simples est l'opérateur de Sobel.

Il utilise deux noyaux de convolution, un pour détecter les bords horizontaux et l'autre pour les bords verticaux.

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
import cv2

def detect_edges(image, threshold):
    sobel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
    sobel_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])

    edge_x = signal.convolve2d(image, sobel_x, mode='same', boundary='symm')
    edge_y = signal.convolve2d(image, sobel_y, mode='same', boundary='symm')

    edge_magnitude = np.sqrt(edge_x**2 + edge_y**2)
    edge_magnitude = edge_magnitude > threshold

    return edge_magnitude.astype(int)

image = plt.imread('bird.png')
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

edges = detect_edges(gray_image, threshold=50)

plt.imshow(edges, cmap='gray')
plt.title('Détection de Bords')
plt.show()

Dans ce code, detect_edges prend une image et un seuil comme arguments. Il définit les noyaux de Sobel pour les directions x et y, puis effectue la convolution de l'image avec ces noyaux. La magnitude des bords est calculée comme la racine carrée de la somme des carrés des réponses des convolutions en x et y. Enfin, un seuil est appliqué pour déterminer les pixels qui sont considérés comme des bords. L'ajustement du seuil permet de varier la sensibilité de la détection des bords, capturant des détails plus ou moins importants.

Affinage d'Image

L'affinage d'image vise à améliorer la netteté des détails sans introduire de bruit excessif. Une méthode courante est d'ajouter une portion de la magnitude du gradient à l'image floue.

Cette technique accentue les transitions de pixels, rendant les bords plus définis.

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
import cv2

def sharpen_image(image, alpha):
    sobel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
    sobel_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])

    edge_x = signal.convolve2d(image, sobel_x, mode='same', boundary='symm')
    edge_y = signal.convolve2d(image, sobel_y, mode='same', boundary='symm')

    edge_magnitude = np.sqrt(edge_x**2 + edge_y**2)

    sharpened_image = image + alpha * edge_magnitude
    sharpened_image = np.clip(sharpened_image, 0, 255).astype(np.uint8)

    return sharpened_image

image = plt.imread('bird.png')
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

sharpened = sharpen_image(gray_image, alpha=0.5)

plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.imshow(gray_image, cmap='gray')
plt.title('Image Originale')

plt.subplot(1, 2, 2)
plt.imshow(sharpened, cmap='gray')
plt.title('Image Affinée')

plt.show()

Ici, sharpen_image prend une image et un facteur alpha comme arguments. Il calcule la magnitude du gradient en utilisant les noyaux de Sobel, puis ajoute une portion de ce gradient à l'image d'origine. La fonction np.clip assure que les valeurs de pixel restent dans la plage valide de 0 à 255. Le facteur alpha contrôle l'intensité de l'affinage, permettant d'ajuster le résultat selon les besoins spécifiques. Un facteur plus élevé accentue davantage les détails, mais peut aussi augmenter le bruit.

Préparation des Images

Le traitement d'image commence par l'importation et la préparation des images. L'image doit être chargée en mémoire et convertie dans un format approprié.

Voici un exemple simple :

import matplotlib.pyplot as plt
import cv2

image = plt.imread('bird.png')
gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

Ici, nous utilisons plt.imread pour charger l'image et cv2.cvtColor pour la convertir en niveaux de gris. La conversion en niveaux de gris simplifie le traitement, car elle réduit le nombre de canaux de couleur à un seul, facilitant ainsi les calculs ultérieurs.

Appliquer le Flou d'Image

Une fois l'image préparée, nous pouvons appliquer le flou. La taille du noyau de convolution est un paramètre clé à ajuster.

Un noyau plus grand entraîne un flou plus prononcé.

from scipy import signal
import numpy as np

def apply_blur(image, kernel_size):
    kernel = np.ones((kernel_size, kernel_size)) / (kernel_size ** 2)
    blurred_image = signal.convolve2d(image, kernel, mode='same', boundary='symm')
    return blurred_image

blurred = apply_blur(gray_image, kernel_size=5)

Nous utilisons la fonction signal.convolve2d de SciPy pour effectuer la convolution. Le mode 'same' garantit que la taille de l'image de sortie est la même que celle de l'entrée, et boundary='symm' gère les bords de l'image de manière symétrique.

Mettre en Œuvre la Détection de Bords

Pour la détection de bord, nous utilisons les opérateurs de Sobel pour calculer les gradients horizontaux et verticaux. Un seuil est appliqué pour identifier les bords significatifs.

def detect_edges(image, threshold):
    sobel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
    sobel_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])

    edge_x = signal.convolve2d(image, sobel_x, mode='same', boundary='symm')
    edge_y = signal.convolve2d(image, sobel_y, mode='same', boundary='symm')

    edge_magnitude = np.sqrt(edge_x**2 + edge_y**2)
    edge_magnitude = edge_magnitude > threshold

    return edge_magnitude.astype(int)

edges = detect_edges(gray_image, threshold=50)

En ajustant le seuil, nous pouvons affiner les détails capturés comme des bords. Un seuil plus bas détectera plus de bords, mais risque aussi de capturer davantage de bruit.

Affiner les Images

L'affinage combine l'image floue avec la magnitude du gradient pour rehausser les détails.

Le facteur alpha contrôle l'intensité de l'affinage.

def sharpen_image(image, alpha):
    sobel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
    sobel_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])

    edge_x = signal.convolve2d(image, sobel_x, mode='same', boundary='symm')
    edge_y = signal.convolve2d(image, sobel_y, mode='same', boundary='symm')

    edge_magnitude = np.sqrt(edge_x**2 + edge_y**2)

    sharpened_image = image + alpha * edge_magnitude
    sharpened_image = np.clip(sharpened_image, 0, 255).astype(np.uint8)

    return sharpened_image

sharpened = sharpen_image(gray_image, alpha=0.5)

Il est crucial de limiter les valeurs de pixel entre 0 et 255 pour éviter les artefacts visuels. Un alpha trop élevé peut entraîner une surexposition et amplifier le bruit.

Visualisation des résultats

Afin de visualiser les résultats de ces opérations de traitement d'image, il est essentiel d'utiliser une représentation visuelle des images traitées en Python. La bibliothèque Matplotlib offre des outils puissants pour afficher des images et comparer différents résultats. Voici comment afficher une image à l'aide de Matplotlib :

import matplotlib.pyplot as plt

plt.imshow(image, cmap='gray')
plt.title('Image traitée')
plt.show()

Dans ce code, plt.imshow affiche l'image, et cmap='gray' spécifie une palette de couleurs en niveaux de gris. Utiliser plt.subplot et plt.show permet de générer une figure à plusieurs panneaux pour afficher plusieurs images côte à côte et comparer les résultats de différentes opérations de traitement. Cette étape de visualisation est cruciale pour évaluer l'efficacité des opérations et ajuster les paramètres en conséquence.