Cours:Elen4 TNS TP TraitImage

Retour à la page du cours

TP4 : Traitement d'images numériques

Le travail de ce TP va consister à

• observer et manipuler (simplement) la représentation spatiale d'images numériques;
• observer et interpréter le contenu fréquentiel des images;
• appliquer des filtres linéaires pour : débruiter des images ou faire apparaitre leurs contours;
• détecter des motifs dans des images

Représentation des images numériques

Une image numérique est un signal numérique bidimensionnel. C'est donc une fonction réelle ou complexe de deux variables indépendantes. De manière générale, une image est représentée par :

x(k,l) avec k,l ∈ ℤ

Si les domaines de variation des variables sont finis, alors le signal x(k,l) peut être représenté par une tableau rectangulaire.

Nous aurons besoin de la librairie scikit-image :

pixi add scikit-image

Chargement et visualisation

En partant de ce code exemple pour charger une image et l'afficher avec une palette en niveaux de gris :

def fastshow(img):
    plt.imshow(img, cmap='gray')
    plt.colorbar()
    plt.show()

img = skimage.io.imread(filename)
print(img.shape)
fastshow(img)

     Charger et afficher l’image coins.png

     Observer comment sont stockées les valeurs des pixels dans le tableau I.

Modification de niveaux de gris

a) Puisque les valeur de luminance sont (pour l'image coins) codées sur 8 bits. Il est possible d'inverser la palette (en niv. de gris) par la transformation suivante

Y(k,l) = 255 - X(k,l)

     Inverser l'image coins et afficher le résultat.

b) Pour binariser une image, le plus simple est de choisir une valeur seuil :

si X(k,l)>seuil	Y(k,l)=1
sinon	Y(k,l) = 0

     Choisir une valeur seuil pour permettre de binariser l'image de façon à afficher les pièces en blanc sur fond noir.

     Essayer de faire de même avec l'image rice.png.

Images couleurs

a) Lire l'image ngc6543a.jpg.

b) Observer comment sont stockées les valeurs des pixels dans le tableau. Que représente la troisième dimension ?

c) Binariser l'image pour obtenir une image binaire faisant apparaitre le noyau de la galaxie seul.

Contenu fréquentiel des images

On utilisera une image test de caméraman :

X = scikit.io.imread('cameraman.png')

a) Lire et afficher l'image X.

b) Calculer ses coefficients de Fourier à l'aide de la fonction numpy.fft.fft2() (FFT en deux dimensions).

c) Calculer et afficher les spectres d'amplitude et de phase.

• Pour centrer l'affichage des fréquences, il est commode d'utiliser numpy.fft.fftshift(...)
• Il sera probablement judicieux d'utiliser une échelle log pour les intensités des harmoniques : numpy.log(1++...)

d) Essayer d'interpréter le contenu fréquentiel à partir de l'image du spectre d'amplitude, et de l'image du spectre de phase.

Débruitage

De façon similaire au TP n°3, l'objectif est de filtrer une image

Xb(k,l) = X(k,l) + B(k,l)

X etant une image 'propre' et B une image de bruit.

Pour X, on prendra l'image cameraman convertie en float:

X = scikit.io.imread('cameraman.png')
X = scikit.img_as_float(X)

Bruitage

a) À l'aide de la fonction scikit.util.random_noise, créer :

• une image Xb1 en ajoutant à l'image X du bruit gaussien
• et une image Xb2 en ajoutant à l'image X du bruit poivre et sel (salt-and-pepper)

     Afficher les images Xb1 et Xb2 pour observer les deux types de bruit

Débruitage linéaire

Pour réduire le bruit, il est possible d'appliquer un filtre moyenneur dont voici la réponse impulsionnelle :

1/9	1/9	1/9
1/9	1/9	1/9
1/9	1/9	1/9

b) A l'aide de la fonction scipy.ndimage.convolve, appliquer le filtre moyenneur aux images Xb1 et Xb2.

     Estimer la qualité du débruitage linéaire sur chaque image.

Débruitage non-linéaire

c) Il est possible d'appliquer des filtres non-linéaires. Dans notre cas, vous pouvez tester l'effet d'un filtre non-linéaire de type médiane (à la place de la moyenne) :

Y2 = sp.ndimage.generic_filter(Xb2,
                               np.median,
                               size=3)

     Apprécier la qualité de ce débruitage non-linéaire sur chaque image.

Détection de contours

Les contours d'une image sont souvent obtenus à partir d'une dérivée de l'image (contour = position d'une variation de grande amplitude). Puisqu'une image est à deux dimensions, il est possible de calculer deux dérivées (une sur chaque dimension), ce qui conduit à l'application de deux filtres dont voici les réponses impusionnelles :

Dx =

0	0	0
1	0	-1
0	0	0

et

Dy =

0	1	0
0	0	0
0	-1	0

a) En travaillant avec l'image caméraman, obtenir Gx et Gy, résultats de l'application des filtres de réponse impulsionnelle Dx et Dy sur cette image (en utilisant scipy.ndimage.convolve(...)).

     Afficher et apprécier visuellement le résultat

b) En pratique, Gx et Gy sont les deux composantes d'un gradient dont on peut calculer une norme :

||G|| = (Gx² + Gy²)^1/2

     Calculer l'image G et l'afficher.

c) Avec la même méthode, obtenir la norme du gradient de l'image caméraman bruitée par du bruit gaussien (Xb1 dans la partie Débruitage précédente).

     Observer le comportement du filtre. Quel est le problème ?

d) Pour y remédier, une méthode consiste à moyenner les pixels dans la direction orthogonale à celle où la dérivée est appliquée. Ce qui conduit aux deux filtres de Sobel, dont voici les réponses impulsionnelles :

Sx =

1	0	-1
2	0	-2
1	0	-1

et

Sy =

1	2	1
0	0	0
-1	-2	-1

     Filtrer l'image caméraman avec ces deux réponses impulsionnelles, calculer la norme du gradient, et comparer avec le résultat précédent. En cas de soucis, utiliser l'implémentation de scikit-image : skimage.filters.sobel