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

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

ba

byaxIbahyxF,

),(),(),(

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 :

)(

21

,

212211

21

),(),(nwnwj

nn

ennhwwH

),(),( ),( ),(

),(),( ),( ),)(*( ),(

* vuHyxGouyxhyxgou

vuIvuGvuFyxIgyxF

yx

MuyNuxjeyxIvuI,

)//(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 :

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

- 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 :

Figure VI-1 : Page d’accueil de l’application

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.

Figure VI-3 : fenêtre permettant d’appliquer des algorithmes de traitement d’images

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.