Feuille de TP n°5 - Institut de Mathématiques de Toulouse

Feuille de TP n°5
Licence 3 MApI3, module Signal, Fourier, image
1
Ondelettes
Pour ce TP, on utilisera la bibliothèque supplémentaire pywavelets disponible sur le site http://www.
pybytes.com/pywavelets/.
Listing 1 – Installation de la librairie pywavelets
1
2
3
R é c u p é r e r get p i p . py d e p u i s h t t p : / / p i p . r e a d t h e d o c s . o r g / en / l a t e s t / i n s t a l l i n g . html
Taper dans un t e r m i n a l : python get p i p . py
user
Taper dans un t e r m i n a l : p i p i n s t a l l PyWavelets
user
Exercice 1 – Codage des ondelettes de Daubechies. L’objet de ce premier exercice est de coder la transformée en ondelettes de Daubechies à 2 et 4 moments nuls. On rappelle que les ondelettes de Daubechies ont la
propriété de constituer un jeu d’ondelettes orthogonales. On rappelle également que les ondelettes orthogonales
sont construites à partir de deux filtres h et g de RN (que l’on suppose périodisés en dehors de f0; ; N 1g)
ayant les propriétés
jh^ k j2 + jh^ k+N=2 j2 = 2
et
gm = (
Alors, l’ensemble
fhm 2l gl2f0;:::; N2
m) h
(1
1)
1
m;
m 2 f0; ; N
g:
1
g [ fgm 2l gl2f0;:::; N2 1g est une base orthogonale de RN .
1
Les ondelettes de Daubechies à deux moments nuls sont construites à partir des coefficients
c0 = p
1 1+
On a alors
2
p
4
3
; c1 = p
1 3+
2
p
4
3
; c2 = p
1 3
2
p
3
4
; c3 = p
p
1 1
4
2
3
:
h =t (c0 ; c1 ; c2 ; c3 ; 0; ; 0) 2 RN ;
et
g =t ( c1 ; c0 ; 0; ; 0; c3 ; c2 ) 2 RN :
Partant d’un signal u 2 RN , la décomposition en ondelettes revient à le scinder en deux sous-signaux (résumé
et détails) définis par
u1m = (h u)2m et u2m = (g u)2m , pour m 2 f0; : : : ;
où on note hm
=
N
g;
1
2
h m.
1) En considérant un signal à 8 composantes, représenter ces deux opérations sous la forme d’un système
linéaire.
2) En déduire un algorithme pour réaliser cette transformation sur un signal à
3) Vérifier que partant de
h et g, on a bien une base d’ondelettes orthogonale.
N
composantes.
4) La décomposition en ondelettes revient à appliquer l’algorithme de la question 2 au résumé et de recommencer cette transformation jusqu’à ce que l’on ne puisse plus procéder à cette étape. Construire une fonction
qui fabrique la décomposition en ondelettes jusquà un certain niveau, puis une fonction pour la décomposition
complète. On stockera le résultat dans les deux cas dans un vecteur de RN .
5) Charger la librairie fournie ondelettes.py et utiliser la fonction MakeSignal(n) pour créer un signal à
composantes. Attention au format de retour de cette fonction. Représenter ce signal.
1
n
6) Appliquer la transformation en ondelettes au signal créé. Pour représenter cette décomposition, on dessinera
plusieurs subplot les uns sous les autres. Le premier (en partant du haut) contiendra la représentation du
signal de longueur N . La deuxième figure et les suivantes contiendront les détails calculés aux différents niveaux
(première, puis seconde, puis troisième, décomposition). Attention, dans cette représentation, les détails
contiennent deux fois moins de points que les précédents. Il est donc nécessaire de prendre en compte ce
paramètre pour la représentation.
7) Que constatez-vous ?
8) On souhaite maintenant pouvoir recomposer le signal d’origine à partir de la décomposition en ondelettes.
Pour la recomposition, on note
u~m =
1
On note
(
u1m2
0
, si
, si
m est pair,
m est impair,
u~m =
2
et
(
u2m2
0
u = h u~1 + g u~2
, si
, si
m est pair,
m est impair,
(1)
qui est le résultat de la recomposition.
Fabriquer une fonction Python qui fabrique cette recomposition. Vérifier votre fonction en essayant de retrouver
votre signal de départ.
9) Reprendre les questions précédentes en considérant les coefficients du polycopié du cours qui correspondent
aux coefficients des ondelettes de Daubechies à 4 moments nuls. On reproduit le jeux de coefficients ci-dessous
8
0:230377813309
>
>
>
>
0:714846570553
>
>
>
>
>
0:630880767930
>
>
>
>
< 0:027983769417
hm = > 0:187034811719
>
>
0:030841381836
>
>
>
>
0:032883011667
>
>
>
>
>
>
: 0 0:010597401785
,
,
,
,
,
,
,
,
,
si m = 0;
si m = 1;
si m = 2;
si m = 3;
si m = 4;
si m = 5;
si m = 6;
si m = 7;
sinon.
Exercice 2 – Ondelettes de Daubechies pour les images. L’obtention de la décomposition en ondelettes
pour les images se réalise comme pour la transformée de Fourier à deux dimensions :
2
— on décompose avec une décomposition en ondelettes 1D toutes les lignes de l’image u 2 RN et on met
N
N
les résultats dans les lignes de deux images u1 2 RN 2 et u2 2 RN 2 ;
— puis on décompose avec une décomposition en ondelettes 1D toutes les colonnes des deux images u1 et
N 2
N 2
N 2
N 2
u2 pour obtenir quatre images de coefficients u11 2 R( 2 ) , u12 2 R( 2 ) , u21 2 R( 2 ) et u22 2 R( 2 ) .
1) Fabriquer une fonction Python qui réalise une étape de la décomposition en ondelettes pour une image.
Pour la décomposition 1D, on obtenait le résumé et les détails. On obtient maintenant quatre sous-matrices,
une pour le résumé, et trois pour les détails. Le résultat devra être renvoyé sous la forme d’une image de même
taille. On s’inspirera pour cela de l’illustration de la figure 1.
2) Visualiser les résumés successifs d’une décomposition en ondelettes d’une image 2D (on pourra prendre à
titre d’exemple lena ou barbara).
3) Fabriquer une fonction Python qui réalise la décomposition en ondelettes jusqu’à un certain niveau d’une
image puis une deuxième fonction qui réalise la décomposition complète.
4) Utiliser la fonction Affiche_Dec_Ondelettes(u,k) de la librairie ondelettes.py pour afficher le résultat
de la décomposition en ondelettes d’une image (que l’on aura stocké dans la variable u) à k niveaux.
5) Fabriquer des fonctions Python qui effectuent la transformation inverse de la décomposition à niveau et
globale en ondelettes et les tester.
2
Figure 1 – Algorithme permettant le calcul des coefficients d’ondelettes 2D.
2
Débruitage
Lors de l’acquisition d’une image, plusieurs défauts peuvent parasiter le résultat final. L’un des défauts
majeurs est l’apparition de bruit (par exemple lors de poses longues ou des photos sous faible luminosité). On
considère un modèle simple de bruit pour les images
U = u0 + W
où u0 est une image déterministe composée de N pixels et W un bruit gaussien distribué suivant N (0; 2 IdN ),
~ de u0 qui ne dépend
où 2 est la variance du bruit. Le but du débruitage est de définir un estimateur U
~
que de U , c’est à dire U = (U ), où est potentiellement une application non linéaire. Bien que u0 soit une
~ sont des variables aléatoires. Le but du débruitage est de réduire autant que
image déterministe, à la fois U et U
possible l’erreur de débruitage en utilisant quelques connaissances a priori sur l’image inconnue u0 . Une manière
~
mathématique de mesurer cette erreur est de borner l’erreur quadratique EW (kU
u0 k2 ), où l’espérance est
calculée par rapport au bruit W .
Dans les applications réelles, on n’a pas accès à l’image de départ u0 . Cependant, on suppose ici que u0 est
connue et que u = u0 + w est générée en utilisant une seule réalisation du bruit w qui est issu de W . On définit
l’estimation de l’image déterministe comme u
~ = (u) qui est une réalisation de l’image aléatoire u
~.
Exercice 3.
1) Définir un écart type
de valeur 0:08.
2) Charger une image (lena ou barbara) et ajouter un bruit de variance 2 . On prendra soin avant d’ajouter
le bruit de normaliser l’image pour que les valeurs de chaque pixel soient comprises dans l’intervalle [0; 1]. On
pourra utiliser la commande
u = u0 + sigma*random.standard_normal(u0.shape)
pour ajouter le bruit.
On va dans un premier temps considérer la suppression du bruit par moyenne locale. Cela consiste à faire subir
une modification aux valeurs des pixels. L’opération la plus simple consiste à remplacer la valeur a de chaque
pixel par la moyenne de a et des 8 valeurs b,c,d,e,f,g,h,i des 8 pixels voisins de a. Les valeurs des pixels
sont positionnées comme suit :
0
1 0
1
g c h
@ b a dA = @192
79
54
47
190
153
166
189
203
f e i
a par
a+b+c+d+e+f +g+h+i
A
On obtient ainsi une image modifiée en remplaçant
9
3
:
= 141 4
En effectuant cette opération pour chaque pixel, on supprime une partie du bruit.
3) Construire une fonction python qui réalise le débruitage par moyenne. On supposera que les images sont
périodiques.
4) Tester votre fonction sur plusieurs images bruitées. Que constatez-vous ? Tester avec une moyenne sur un
plus grand nombre de points (25, 49, 81).
5) Plutôt que d’utiliser la moyenne des pixels voisins, on choisit maintenant d’utiliser la médiane. Répéter les
questions préćedentes. Que constatez vous ?
On souhaite utiliser maintenant la décomposition en ondelettes pour réaliser le débruitage. Il est possible
d’utiliser les fonctions qui ont été développées précédemment. Cependant, elles sont assez lentes et les optimiser
prendrait du temps. Dorénavant, on utilisera les fonctions python pour le calcul par ondelettes : pour décomposer
une image en ondelette, on utilisera la commmande v=db_fwd_2D_pywt(u) et pour recomposer une image, on
tapera u=db_bck_2D_pywt(v).
Débruitage par troncature dure
Un estimateur non linéaire de débruitage simple mais efficace est obtenu en tronquant les coefficients de u
dans une base orthogonale bien choisie. Nous choisissons dans ce TP les bases d’ondelettes de Daubechies.
L’opérateur de troncature dure avec un niveau T 0 appliqué à une image u est défini par
ST0 (u) =
X
j<u; m >j>T
< u; m > m =
avec
s0T () =
L’estimateur de débruitage et alors défini par
0
X
m
s0T (< u; m >) m
si jj > T;
sinon:
u~ = ST0 (u).
6) Définir une fonction Python thresh_hard(a,T) qui prend en entrée des coefficients d’ondelettes a d’une
image u et un niveau T et qui renvoie les coefficients d’ondelettes que l’on aura tronqués suivant la méthode
ci-dessus.
7) La valeur du coefficient de troncature T doit être proportionnelle au niveau de bruit . On prendra par
exemple T = 3 . Appliquer la fonction thresh_hard aux coefficients d’ondelettes d’une image bruitée et afficher
la recomposition à partir de ce nouveau jeu de coefficients et interpréter.
Débruitage par troncature douce
L’image estimée u
~ obtenue par troncature dure peut souffrir de plusieurs artefacts. Il est possible d’améliorer
le résultat en utilisant une troncature douce définie par
ST1 (u) =
avec
X
m
s1T (< u; m >) m
sT () = max
1
;
0 1
T
jj :
8) Définir une fonction Python thresh_soft(a,T) qui prend en entrée des coefficients d’ondelettes a d’une
image u et un niveau T et qui renvoie les coefficients d’ondelettes que l’on aura tronqué suivant la méthode
ci-dessus.
9) La valeur du coefficient de troncature T doit être proportionnel au niveau de bruit . On prendra par
exemple T = (3=2) . Appliquer la fonction thresh_hard aux coefficients d’ondelettes d’une image bruitée et
afficher la recomposition à partir de ce nouveau jeu de coefficients et interpréter.
On peut prouver que si l’erreur d’approximation non linéaire ku0 ST (u0 )k2 décroit rapidement vers 0 quand
T décroit, alors l’erreur quadratique E(kU~ ST (u)k2 ) décroit aussi vers 0 quand décroit. Pour quepce résultat
soit vrai, il est nécessaire de sélectionner la valeur de troncature comme la valeur universelle T = 2 log N .
10)On souhaite déterminer la meilleure valeur de troncature T à la fois pour le débruitage à troncature douce
et à troncature dure. Tester pour cela plusieurs valeurs de T dans l’intervalle [:8; 4:5 [ et afficher l’erreur SNR
(Signal to Noise Ratio) 10 log10 (ku0 u
~ k=ku0 k). Que peut-on en conclure ?
4
3
Compression
Exercice 4.
Les fonctions développées à l’exercice précédent permettent aussi de compresser des images.
1) Réaliser la décomposition en ondelettes d’une image et stocker le résultat dans la variable a.
2) Recomposer en ne conservant que le résumé et quelques niveau de détails de a. Afficher l’image et interpéter
a et recomposer l’image. Afficher l’image et interpéter
Appliquer le filtre de débruitage à troncature douce à a et recomposer l’image. Afficher l’image et interpéter
3) Appliquer le filtre de débruitage à troncature dure à
4)
5