Vous êtes sur la page 1sur 18

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');
subplot(1,2,2);imshow(J);title('apres 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');

On peut visualiser le résultat sur la figure I-3:


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 :

F ( x, y)   h(a, b) I ( x  a, y  b)
a ,b

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');
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 :

H ( w1 , w2 )  
n1 , n2
h(n1 , n2 )e  j ( w1n1  w2n2 )

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
F ( x, y)  ( g * I )( x, y)  F (u, v)  G(u, v) I (u, v)
ou g ( x, y)  h( x, y) ou G( x, y)  H * (u, v)

La transformée de Fourier discrète est donnée par :

I (u, v)   I ( x, y)e  j 2 (ux/ N uy / M )


x, y
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 :

Figure III-2 : Application du filtre de Sobel


 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);
subplot(1,3,3); imshow(j);
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:

Figure V-1 : Module du gradient


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, imshow(fgm), title('les maxima régionaux')
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, imshow(bgm), title('Lignes de partage des eaux')
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')

Figure V-5 : Superposition des marqueurs et lignes de partages sur l’image


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
- la compréhension de la bibliothèque mathématique
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.