Filtres de traitement d’image

Les filtres sont des opérations mathématiques qui produisent une nouvelle image à partir d’une ou plusieurs images. Les valeurs des pixels entre les images d’entrée et de sortie peuvent différer.

import numpy as np

import matplotlib.pyplot as plt
from skimage.io import imread
from skimage import data
from skimage import filters
from skimage import morphology
from scipy.ndimage import convolve, gaussian_laplace
import stackview

Pour démontrer ce que font des filtres spécifiques, nous commençons par une image très simple. Elle contient beaucoup de zéros et un seul pixel avec la valeur 1 au milieu.

image1 = np.zeros((5, 5))
image1[2, 2] = 1
image1

array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

plt.imshow(image1, cmap='gray')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x162d12abe80>

Noyau gaussien

Pour appliquer un flou gaussien à une image, nous la convoluons en utilisant un noyau gaussien. La fonction gaussian dans scikit-image peut faire cela pour nous.

blurred = filters.gaussian(image1, sigma=1)
blurred

array([[0.00291504, 0.01306431, 0.02153941, 0.01306431, 0.00291504],
       [0.01306431, 0.05855018, 0.09653293, 0.05855018, 0.01306431],
       [0.02153941, 0.09653293, 0.15915589, 0.09653293, 0.02153941],
       [0.01306431, 0.05855018, 0.09653293, 0.05855018, 0.01306431],
       [0.00291504, 0.01306431, 0.02153941, 0.01306431, 0.00291504]])

plt.imshow(blurred, cmap='gray')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x162d1363d00>

Laplacien

Chaque fois que vous vous demandez ce qu’un filtre pourrait faire, créez simplement une image de test simple et appliquez-lui le filtre.

image2 = np.zeros((9, 9))
image2[4, 4] = 1

plt.imshow(image2, cmap='gray')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x162d1438fd0>

mexican_hat = filters.laplace(image2)

plt.imshow(mexican_hat, cmap='gray')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x162d1b312b0>

Laplacien de gaussienne

Nous pouvons également combiner des filtres, par exemple en utilisant des fonctions. Si nous appliquons un filtre gaussien à une image puis un laplacien par la suite, nous avons par définition un filtre réalisant le Laplacien de gaussienne (LoG).

def laplacian_of_gaussian(image, sigma):
    """
    Applique un noyau gaussien à une image puis le laplacien par la suite.
    """
    
    # flouter l'image en utilisant un noyau gaussien
    intermediate_result = filters.gaussian(image, sigma)
    
    # appliquer le filtre chapeau mexicain (Laplacien)
    result = filters.laplace(intermediate_result)
    
    return result

log_image1 = laplacian_of_gaussian(image2, sigma=1)

plt.imshow(log_image1, cmap='gray')
plt.colorbar()

<matplotlib.colorbar.Colorbar at 0x162d1bc5dc0>

Réglage interactif des paramètres de filtre

Pour mieux comprendre ce que font les filtres, il est recommandé de les appliquer de manière interactive. Le code suivant ne s’affichera pas sur github.com. Vous devez exécuter le notebook localement pour utiliser cette interface utilisateur interactive.

image3 = imread('../../data/mitosis_mod.tif').astype(float)

stackview.interact(laplacian_of_gaussian, image3, zoom_factor=4)

Exercice

Écrivez une fonction qui calcule la Différence de gaussiennes.

def difference_of_gaussian(image, sigma1, sigma2):
    
    # entrez le code ici

Utilisez un simple appel de fonction pour essayer la fonction.

dog_image = difference_of_gaussian(image3, 1, 5)

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

Utilisez la bibliothèque stackview pour jouer avec de manière interactive.

stackview.interact(difference_of_gaussian, image3)