Introduction générale
Avec la parole, l’image constitue l’un des moyens les plus importants qu’utilise l’homme pour communiquer avec autrui. C’est un moyen de communication universel dont la richesse du contenu permet aux êtres humains de tout âge et de toute culture de se comprendre.
C’est aussi le moyen le plus efficace pour communiquer, chacun peut analyser l’image à sa manière, pour en dégager une impression et d’en extraire des informations précises.
De ce fait, le traitement d’images est l’ensemble des méthodes et techniques opérant sur celles-ci, dans le but de rendre cette opération possible, plus simple, plus efficace et plus agréable, d’améliorer l’aspect visuel de l’image et d’en extraire des informations jugées pertinentes.
Dans ce cadre s’inscrit ce projet qui porte sur le développement d’une application permettant d’intégrer sous une seule interface graphique des outils de traitement et de manipulation d’images. Cette application sera développée sous Matlab à l’aide du toolbox GUIDE .
1)
Définition de l’image :
L’image est une représentation d’une personne ou d’un objet par la peinture, la sculpture, le dessin, la photographie, le film, etc. C’est aussi un ensemble structuré d’informations qui, après affichage sur l’écran, ont une signification pour l’œil humain.
Représentation des images numériques :
une image numérique est une matrice de pixels repérés par leur coordonnées (x,y). S'il s'agit d'une image couleur, un pixel est codé par 3 composantes (r,g,b) (chacune comprise au sens large entre 0 et 255), représentant respectivement les "doses" de rouge, vert et bleu qui caractérisent la couleur du pixel. S'il s'agit d'une image en niveau de gris, il est codé par 1 composante comprise au sens large entre 0 et 255, représentant la luminosité du pixel.
2)
Traitements d’image :
Pour manipuler une image, on travaille sur un tableau d'entiers qui contient les composantes de chaque pixel. Les traitements s'appliquent toujours aux images en niveau gris et parfois aussi sur des images couleur. Nous allons distinguer plusieurs types de traitements dans ce projet.
2.1 ) Changement de format de l’image sous Matlab :
L'œil humain possède des récepteurs pour les trois couleurs primaire rouge, vert et bleu. Ainsi, tous les espaces couleur ont trois dimensions. Il ya plusieurs espaces de couleurs disponibles, les plus connus étant RVB (Rouge-Vert-Bleu), HSV (Hue-Saturation-Valeur) et NTSC.
Conversion en intensité RGB :
Cette conversion est réalisée en appliquant le script suivant:
I = imread('fleur.jpg'); I = double(I)/255.0; R = I(:,:,1); G = I(:,:,2); B = I(:,:,3); J=rgb2ntsc(I); figure(1);subplot(1,5,1);imshow(I);title('avant'); subplot(1,5,2);imshow(R);title('R'); subplot(1,5,3);imshow(G);title('G'); subplot(1,5,4);imshow(B);title('B');
La figure I-1 montre le résultat de la conversion:
Figure I-1 : Résultats de la conversion en RGB
Conversion de RGB vers NTSC
NTSC est l'espace de couleur utilisé pour la diffusion de la télévision aux États-Unis, et le seul espace entre les ci-dessus ceux qui sont mentionnés qui réalise une séparation complète entre la luminance et la chrominance de l'information. NTSC a cette propriété, car lorsqu’elle a été introduite, il fallait séparer les informations utilisées par les récepteurs de télévision monochrome de celui supplémentaires utilisées par les récepteurs couleur. Les composantes de l'espace colorimétrique NTSC sont Y (la composante de luminance), I (la composante cyan-orange), et Q (la composante verte-mauve).
Le code Matlab qui suit permet de réaliser cette conversion :
I = imread('fleur.jpg');
I = double(I)/255.0 R = I(:,:,1);
J=rgb2ntsc(I);
figure(1);subplot(1,2,1);imshow(I);title('avant traitement');
Le résultat est visualisable sur la figure I-2 :
Figure I-2 : Résultats de la conversion en NTSC
Conversion avec la représentation HSV
HSV est un terme anglais qui signifie (hue, saturation, value) ou encore en français TSV (teinte, saturation, valeur).Il s’agit d’un espace colorimétrique, défini en fonction de ses trois composantes :
On code la teinte suivant l'angle qui lui correspond sur le cercle des couleurs (0° ou 360° : rouge ;60° : jaune ;120° : vert ;180° : cyan ;240° : bleu ;300° …). La saturation est l’intensité de la couleur et elle varie entre 0 et 100 %. Plus la saturation d'une couleur est faible, plus l'image sera « grisée » et plus elle apparaitra fade, il est courant de définir la « désaturation » comme l'inverse de la saturation. Enfin la valeur est la « brillance » de la couleur et elle varie entre 0 et 100%. Plus la valeur d'une couleur est faible, plus la couleur est sombre.
Le modèle TSV a été créé en 1978 par Alvy Ray Smith. C'est une transformation non-linéaire de l'espace de couleur RVB, et peut être utilisé en progression colorique.
Le code suivant développé sous Matlab permet de réaliser cette représentation :
I = imread('fleur.jpg');
[x,map]=rgb2ind(I,128); imview(x,map);
maphsv=rgb2hsv(map);
[H,S,V]=ind2rgb(x,maphsv);
figure(1);subplot(1,4,1);imshow(x,map);title('image couleur');
subplot(1,4,2);imshow(H);title('H');
subplot(1,4,3);imshow(S);title('S');
subplot(1,4,4);imshow(V);title('V');
Figure I-3 : Résultats de la conversion en HSV
2.2) Filtrage d’images :
Pour améliorer la qualité visuelle de l’image, on doit éliminer les effets des bruits (parasites) en lui faisant subir un traitement appelé filtrage.
Le filtrage consiste à modifier la distribution fréquentielle des composantes d’un signal selon des spécifications données. Le système linéaire utilisé est appelé filtre numérique.
La section qui suit va exposer quelques codes permettant de réaliser l’opération de filtrage :
Réduction de bruit avec un filtre linéaire :
Le filtrage de l’image I par le filtre h est une image F dont les luminances sont données par :
Le code suivant permet de réaliser le filtrage de l’image :
I=imread('fleur.jpg'); //Lecture de l’image
J=rgb2gray(I); J=double(J)/255.0;
h=-ones(3,3); // Definition de h h(2,2)=8;
F=filter2(h,J); // Filtrer F
//visualization des resultat
figure(2 );subplot(1,2,1);imshow(I);title('image originale');
subplot(1,2,2);imshow(F);title('image filtrée');
b a b y a x I b a h y x F , ) , ( ) , ( ) , (On peut jouer sur l’intensité du filtre et on peut remarquer que l’image est plus nette lorsque la valeur de l’intensité est plus importante. Le résultat est visualisé sur la figure II-1
Figure II-1 : Filtrage linéaire
Synthèse d’un filtre par échantillonnage de fréquence
On a :
Le principe consiste à indiquer les valeurs souhaitées de H(w1,w2) sur une grille (w1, w2) et à
en déduire le filtre h(n1 ,n2).
Il est également possible de réaliser le filtrage dans le domaine fréquentiel. Pour cela, on multiplie la transformée de Fourier de l’image par le conjugué de la réponse fréquentielle du filtre.
Soit I l’image source, F l’image filtrée, h le filtre, et I, F, H, les transformées de Fourier. On a donc
La transformée de Fourier discrète est donnée par :
) ( 2 1 , 2 1 2 2 1 1 2 1 ) , ( ) , ( jwn wn n n e n n h w w H
) , ( ) , ( ) , ( ) , ( ) , ( ) , ( ) , ( ) , )( * ( ) , ( * v u H y x G ou y x h y x g ou v u I v u G v u F y x I g y x F
y x M uy N ux j e y x I v u I , ) / / ( 2 ) , ( ) , ( Le code correspondant est le suivant : I=imread('fleur.jpg'); I1=fft2(I); h= zeros(9,9); h(4:6,4:6)=ones(3,3); H1=fsamp2(h); G = filter2(H1,I); G1=ifft2(G); figure(1);subplot(1,2,1);imshow(G1);title('frequentiel');
subplot(1,2,2);imshow (G);title('impulsionnel');
Réduction de bruit avec le filtre médian :
Lorsqu’une image comporte des pixels aberrants (par exemple un seul pixel blanc au milieu
d'une zone noire ou des pixels isolés répartis aléatoirement dans l'image qui dégradent la qualité de l'image), on dit qu’elle est «bruitée ».
Un simple lissage de l'image permet de réduire le bruit car l'effet des pixels aberrants est amoindri grâce au moyennage avec ses pixels voisins. Cependant, le lissage entraîne une réduction de piqué dans l’image.
La méthode basée sur le filtre médian ne présente pas cet inconvénient. Elle est particulièrement adaptée lorsque le bruit est constitué de points isolés ou de lignes fines. Cependant, elle n'est applicable qu'aux images en niveaux de gris, contrairement au lissage.
Le code de ce filtrage est le suivant :
i=imread('fleur.jpg');
i=rgb2gray(i);
j=imnoise(i,'salt & pepper',0.02);
s= strel('disk',1); k=imopen(j,s); n=imclose(k,s); f=imclose(j,s); p=imopen(n,s); figure(1);subplot(1,5,1);imshow(j); subplot(1,5,2);imshow(k); subplot(1,5,3);imshow(f); subplot(1,5,4);imshow(n); subplot(1,5,5);imshow(p);
La figure II-2 montre le résultat:
Figure II-2 : les étapes de filtrage par filtre median
2.3) Détection de contours :
Le but de la détection de contours est de repérer les points d'une image numérique qui correspondent à un changement brutal de l'intensité lumineuse. La détection des contours d'une image réduit de manière significative la quantité de données et élimine les informations qu'on peut juger moins pertinentes, tout en préservant les propriétés structurelles importantes de l'image. Il existe un grand nombre de méthodes de détection de l'image.
Dans ce qui suit quelques méthodes seront exposées :
filtre de Prewitt :
La matrice qui correspond au filtrage horizontal, faisant ressortir essentiellement les contours verticaux, selon l'opérateur de Prewitt, s'écrit hx = [-1 0 1] tandis que la matrice verticale
hy est sa transposée. Les deux convolutions avec le tableau de valeurs initiales créent deux
tableaux Gxet Gy à l'origine du tableau G sur lequel on peut localiser les maximums.
Afin de réaliser ce filtre sous Matlab on applique le code suivant :
I=imread('fleur.jpg');
J=rgb2gray (I); J=double(J)/255.0; seuil=0.8;
H=fspecial('prewitt'); V=-H'; Gh=filter2(H,J); Gv=filter2(V,J); G=sqrt(Gh.*Gh + Gv.*Gv); Gs=(G>seuil); figure(1);imshow(Gh); figure(2);imshow(Gv); figure(3);imshow(G); figure(4);imshow(Gs);
On visualise le résultat sur la figure III-1 :
Figure III-1 : Application du filtre de Prewitt
le filtre de Sobel :
Le principe de ce filtre est que l'opérateur calcule le gradient de l'intensité de chaque pixel. Ceci indique la direction de la plus forte variation du clair au sombre, ainsi que le taux de changement dans cette direction. On connaît alors les points de changement soudain de luminosité, correspondant probablement à des bords, ainsi que l'orientation de ces bords.
L'opérateur utilise des matrices de convolution. La matrice (généralement de taille 3×3) subit une convolution avec l'image pour calculer des approximations des dérivées horizontale et verticale. Soit l'image source, et deux images qui en chaque point contiennent des approximations respectivement de la dérivée horizontale et verticale de chaque point. Ces images sont calculées comme suit:
En chaque point, les approximations des gradients horizontaux et verticaux peuvent être combinées comme suit pour obtenir une approximation de la norme du gradient:
On implémente alors le script suivant :
I=imread('fleur.jpg'); J=rgb2gray (I); J=double(J)/255.0; seuil=0.8; H=fspecial('sobel'); V=-H'; Gh=filter2(H,J); Gv=filter2(V,J); G=sqrt(Gh.*Gh + Gv.*Gv); Gs1=(G>seuil*4/3); figure(1);imshow(Gh); figure(2);imshow(Gv); figure(3);imshow(G); figure(4);imshow(Gs1);
La figure III-2 montre le résultat suivant :
filtre de robert :
Les filtres de Roberts sont une approche discrète de la dérivée de pas 1 d'une fonction: le gradient de cette fonction.
Si I(x,y) représente un pixel dans une image, alors les amplitudes des gradients en x et en y peuvent s'écrire respectivement:
Gx = I(x+1,y) - I(x,y), Gy = I(x,y+1) - I(x,y).
Cela revient a convoluer l'image avec les deux filtres Rx = [-1 1] et Ry = transpose ([-1 1]). L'amplitude du gradient peut être alors calculée de plusieurs façons:
G1(x,y) = sqrt(Gx^2 + Gy^2),
G2(x,y)= max(abs(Gx),abs(Gy))
ou G3(x,y) = abs(Gx) + abs(Gy).
Et la direction du gradient est donneée par:
D(x,y) = Arctan(Gy/Gx).
Or le bruit peut aussi être une brusque variation locale des niveaux de gris : ces filtres sont donc très sensibles au bruit car ils accentuent, par dérivation, le bruit présent dans l'image. De plus, ces filtres donneront un contour épais si celui-ci est un contour de type "rampe".
Le code utilisé est le suivant :
I=imread('fleur.jpg’); J=rgb2gray (I); J=double(J)/255.0; seuil=0.8; a=[1 0;0 -1]; b=[0 1;-1 0]; Ga=filter2(a,J); Gb=filter2(b,J); G=sqrt(Ga.*Ga + Gb.*Gb); Gs1=(G>seuil*1/3); figure(1);imshow(Ga); figure(2);imshow(Gb); figure(3);imshow(G); figure(4);imshow(Gs1);
La figure III-3 montre les résultats de détection de contours avec ce filtre :
Figure III-3 : Application du filtre de Robert
2.4) Réduction de bruit par un filtre morphologique
En morphologie mathématique, filtrer, c’est conserver l’image en supprimant certaines structures géométriques (en général implicitement définies par un ou plusieurs éléments structurants).
Le filtre morphologique simplifie l’image en lui préservant la structure, mais il perd en général de l’information. Le filtre morphologique est stable et possède une classe d’invariance connue.
Le code correspondant à ce filtre est le suivant :
h=imread ('fleur.jpg');
s= strel('square',15) ;
i=imerode(h,s); j=imdilate(h,s);
figure(1); subplot(1,3,1); imshow(h); subplot(1,3,2); imshow(i);
On visualise la figure IV-1
Figure IV-1 : application du filtre morphologique
2.5) Ligne de partage des eaux :
Dans cette section on va essayer d’appliquer un algorithme de ligne de partage des eaux à l’image d’origine.
En traitement d'images, la segmentation par ligne de partage des eaux (ou watershed en anglais) désigne une famille de méthodes de segmentation d'image issues de la morphologie mathématique qui considèrent une image à niveaux de gris comme un relief topographique, dont on simule l’inondation.
Définitions :
- minimum local : c’est le point ou plateau d’où on ne peut pas atteindre un point plus bas sans être obligé de remonter.
- bassin versant : c’est la zone d’influence d’un minimum local. Une goutte d’eau s’écoulant dans le bassin versant arrive au minimum local
- ligne de partage des eaux : C’est la ligne séparant 2 bassins versants (de cette ligne, une goutte d’eau peut s’écouler vers au moins 2 minima locaux distincts
Principe :
Technique de l’immersion
- On perce chaque minimum local de la surface.
- On inonde la surface à partir des minima locaux, l’eau montant à vitesse constante et uniforme dans les bassins versants.
- Quand les eaux issues de 2 minima différents se rencontrent, on monte une digue pour qu’elles ne se mélangent pas.
- A la fin de l’immersion, l’ensemble des digues constituent la ligne de partage des eaux
Algorithme :
On commence par générer l’image du module du gradient c'est-à-dire les crêtes correspondantes aux contours :
rgb = imread('fleur.jpg');
I = rgb2gray(rgb);
hy = fspecial('sobel');
hx = hy';
Iy = imfilter(double(I), hy, 'replicate');
Ix = imfilter(double(I), hx, 'replicate');
gradmag = sqrt(Ix.^2 + Iy.^2);
figure, imshow(gradmag,[]), title('Module du gradient')
On obtient alors la figure suivante:
Puis on procède à une évaluation de la détection de contours par la LPE et cela en détectant les contours fermés et faisant de la sur-segmentation :
L = watershed(gradmag); Lrgb = label2rgb(L);
figure, imshow(Lrgb), title('Régions détectées par la LPE');
Figure V-2 : Régions détectées par la LPE : sur-segmentation
L’application d’une dilatation et d’une érosion nous servent à détecter les maximas régionaux dans l’image :
se = strel('disk', 20);
Io = imopen(I, se);
figure, imshow(Io), title('ouverture')
Ie = imerode(I, se);
Iobr = imreconstruct(Ie, I);
figure, imshow(Iobr), title('Ouverture par reconstruction(erosion)')
Ioc = imclose(Io, se);
figure, imshow(Ioc), title('Ouverture-Fermeture')
Iobrd = imdilate(Iobr, se);
Iobrcbr = imreconstruct(imcomplement(Iobrd), imcomplement(Iobr)); Iobrcbr = imcomplement(Iobrcbr);
figure, imshow(Iobrcbr), title('Ouverture-Fermeture par reconstruction
(dilatation)')
fgm = imregionalmax(Iobrcbr);
Figure V-3 : Les maxima régionaux
On procède ensuite à la superposition des maximas régionaux sur l’image d’origine puis on refait les mêmes opérations de dilatation et d’érosion. Ces différentes opérations nous permettent de détection les régions dans l’image et on les sépare en utilisant des lignes appelées des lignes de partage des eaux.
I2 = I;
I2(fgm) = 255;
figure, imshow(I2), title(' maxima regional superposé sur l''image
d''origine') se2 = strel(ones(5,5)); fgm2 = imclose(fgm, se2); fgm3 = imerode(fgm2, se2); fgm4 = bwareaopen(fgm3, 20); I3 = I; I3(fgm4) = 255; figure, imshow(I3)
title('maxima regional modifié superposé sur l''image d''origine')
bw = im2bw(Iobrcbr, graythresh(Iobrcbr));
figure, imshow(bw), title('Ouverture-Fermeture par reconstruction
Seuillée') D = bwdist(bw); DL = watershed(D); bgm = DL == 0;
Figure V-4 : Lignes de partage des eaux
On s’intéresse à présent à ce qu’on appelle marqueurs qui existent dans les objets recherchés dans l’images qui sont dans notre cas les bords de l’image
gradmag2 = imimposemin(gradmag, bgm | fgm4); L = watershed(gradmag2);
I4 = I;
I4(imdilate(L == 0, ones(3, 3)) | bgm | fgm4) = 255; figure, imshow(I4)
title('marqueurs et contours superposés sur l''image d''origine')
On obtient enfin la matrice correspondante à l’application de ces contours et marqueurs et qui nous définisse les différentes régions de l’image comme si il s’agissait d’une carte topographique :
Lrgb = label2rgb(L, 'jet', 'w', 'shuffle');
figure, imshow(Lrgb)
title('matrice des lignes de partages des eaux colorée')
figure, imshow(I), hold on
himage = imshow(Lrgb);
set(himage, 'AlphaData', 0.3);
title('superposition transparente sur l''image d''origine');
Figure V-6 : Matrice colorée des régions appliquée sur l’image d’origine
3) Réalisation d’une interface graphique sous la boite à outil
GUIDE de Matlab :
3.1) Pourquoi a-t-on choisi Matlab ?
MATLAB permet le travail interactif soit en mode commande, soit en mode programmation, tout en ayant toujours la possibilité de faire des visualisations graphiques. Il possède les particularités suivantes :
- Puissance de calcul
- la continuité parmi les valeurs entières, réelles et complexes
- l’étendue de gamme des nombres et leurs précisions
- l’inclusion des fonctions d’interface graphique et des utilitaires dans
l’outil graphique
- La possibilité de liaison avec les autres langages classiques de
programmations
Pour l’interface graphique, des représentations scientifiques et même artistiques des objets peuvent être créées sur l’écran en utilisant les expressions mathématiques ou bien directement en utilisant un outil graphique. En effet, pour la conception de notre simulateur nous avons choisi la boite à outil GUIDE sous MATLAB.
3.2 Présentation de la boite à outil GUIDE :
GUIDE ou Graphical User Interface Developpement Environnement est un outil graphique sous MATLAB qui fournit un ensemble d'outils pour créer des interfaces graphiques de façon intuitive. L’utilisateur dispose de plusieurs outils graphiques prédéfinis comme les boutons, les menus… qui lui permettent de créer une interface graphique qui communique avec un programme informatique.
3.3 Présentation de l’application :
La page d’accueil de l’outil est la suivante :
Le Bouton « a propos » donne des informations sur le projet :
Figure VI-6 : Informations sur le projet
En exécutant le bouton « entrer » depuis le menu de démarrage l’interface suivante apparaît :
1
3 2
La zone 1) offre plusieurs outils pour effectuer l’opération de filtrage sur une image.
La zone 2) s’intéresse au changement du format d’image.
La zone 3) offre la possibilité d’utiliser plusieurs filtres pour effectuer la détection de contours de l’image concernée.
En appuyant sur le bouton « plus d’application », une autre fenêtre s’ouvre nous offrant la possibilité soit d’appliquer un filtre morphologique soit de d’applique l’algorithme de lignes de partage des eaux.
Conclusion
La représentation des images fixes est un des éléments essentiels des applications multimédias, comme dans la plupart des systèmes de communication.
La manipulation des images pose cependant des problèmes beaucoup plus complexes que celle du texte. En effet, l’image est un objet à deux dimensions, censé représenter un espace à trois dimensions, ce qui a deux conséquences majeures puisque le volume des données à traiter est beaucoup plus important et la structure de ces données est nettement plus complexe. Il en résulte que la manipulation, le stockage et la représentation de ces données se heurtent à certaines limitations.
Grâce au traitement d’image, ces contraintes sont levées ou contournées. En effet, ce domaine cherche à détecter la présence de certaines formes, certains contours ou certaines textures d’un modèle connu, c’est le problème de la détection.
Un autre aspect de traitement d’image concerne l’analyse et la compréhension de l’image dans le but d’en extraire des informations utiles. Il cherche aussi parfois à comprimer l’image, afin de gagner en vitesse lors de la transmission de l’information, et en capacité de stockage, tout en dégradant le moins possible les images considérées.
Durant ce projet, j’ai eu l’occasion de se rapprocher du monde de traitement d’images en concevant un outil graphique qui peut être utilisé comme un laboratoire de traitement d’images et cela en offrant la possibilité d’effectuer des opérations de filtrage, de détections de contours … et en mettant en place un programme qui permet de détecter toutes les régions de l’image en se basant sur le principe des lignes de partage des eaux.
