Conception, tests et résultats

Conception, tests et résultats Chapitre IV

Chapitre

Conception, tests et résultats

« Success is the sum of small efforts, repeated day in and day out »

-Robert Collier-

48

IV

Introduction


Dans les chapitres précédents, nous avons présenté les fondements théoriques de la

segmentation par ligne de partage des eaux, nous arrivons à présent à la mise en pratique de toutes

ces notions, Dans un premier temps, on s’intéresse au prétraitement : le filtrage, on a implémenté

quelques filtres connu pour leur efficacité ainsi que les opérations morphologiques cités dans

chapitre II, dont le gradient morphologique. Par la suite, c’est la segmentation par LPE.

III.1 Algorithmes de prétraitement

Nous avons implémenté les principaux algorithmes de prétraitement à savoir : les filtres

linéaires : moyenneur et smooth, les filtres non linéaires : médians, maximum et minimum. Et tout

particulièrement les filtres morphologiques exposés dans chapitre II.

III.2.1 Filtres linéaires

49


Les filtres linéaires remplacent chaque pixel par une valeur égale à une somme pondérée de

ses voisins.

Filtre moyenneur : il agit en remplaçant chaque pixel par la moyenne des valeurs des pixels

adjacents et du pixel central. Pour un filtre moyen 3X3, on a le masque :

19

×[1 1 11 1 11 1 1]

III.2.2 Filtres non linéaires

Filtre médian : ce filtre est efficace sur des images dégradées, il permet d’éliminer les pixels

isolés ; son principe est :

-Considérer une fenêtre sur le pixel ;

-Trier les pixels selon un ordre croissant de leur niveau de gris ;

-Affecter au pixel central la valeur médiane.

La valeur médiane est celle qui sépare la séquence triée des valeurs des niveaux de gris en deux

effectifs égaux.

III.2.3 Filtres morphologiques

Nous avons retenu les transformations de base de la morphologie mathématique : érosion,

dilatation, ouverture, fermeture dans les deux cas binaire et en niveau de gris ; ainsi que le filtre

alterné séquentiel et le chapeau haut de forme blanc et noir.

III.2 Segmentation par la détection du gradient

Rappelons que l’image à niveau de gris peut être considérée comme une fonction a deux

variables x, y versR, afin de détecter les changements brusques des valeurs de cette fonction (qui

correspondent aux contours des objets) on peut chercher les extrema de cette fonction en calculant

sa dérivée. Parmi ces opérateurs on peut citer ceux de Sobel, Prewitt, et celui de Laplace sans

oublier le gradient morphologique. Le but de ces opérateurs est de faire apparaitre les pixels qui

50


changent brusquement de valeur par rapport à leur voisinage donc ceux qui correspondent aux

frontières qui séparent les différents objets de l’image.

Le schéma suivant résume la segmentation par la détection du gradient avec la procédure pour

le calcul du gradient Sobel :

III.3

Segmentation par LPE

III.3.1 L’algorithme de Vincent et Soille

Cet algorithme est connu par sa rapidité, il a été amélioré par des prétraitements

morphologiques dans le toolbox de matlab afin de limiter la sur-segmentation engendrée par le

bruit. Son pseudo code est disponible en annexe A.

III.3.2 L’algorithme de Serge Beucher

51

Image au niveau de gris

Prétraitement

Détecteur de gradient

Seuillage

Image résultat


Cet algorithme utilise des files d’attentes hiérarchiques pour améliorer la vitesse d’exécution,

ainsi qu’il combine l’utilisation des marqueurs pour limiter la sur-segmentation, ces principales

fonctions sont :

Fonction FindMinimum ( )

Syntaxe bool FindMinimum ( bool Minimum, CImage *ImgDest=0 );

Paramètres

Minimum [entrée]: Si cette variable est égale à 1, on recherche les minima de l'image. On

recherche les maxima locaux sinon.

*ImgDest [sortie] : Adresse de l'image qui va recevoir le résultat du traitement.

Exemple d'utilisation

CImage *ImgSrc=0,ImgDest;

ImgSrc=new CImage(titre);

ImgSrc->Threashold(128);

ImgSrc->DistanceMorphologique(3,false);

ImgSrc->FindMinimum(false,&ImgDest);

Fonc t ion LPE( )

Syntaxe bool LPE( int Label, int ImgDest, int Neighborhood=4 );

Paramètres

Label [entrée]: Dans ce numéro de buffer doit se trouver l'image des marqueurs.

ImgDest [sortie]: le numéro du buffer de l'image final.

Exemple d'utilisation

52

Image au niveau de gris

Initialisation : -déterminer k niveaux de gris

Affecter chaque pixel à la région (bassin) de niveau de gris le plus proche

Recalculer le nouveau niveau de gris de la région en prenant la moyenne des

niveaux de gris des pixels lui appartenant.

Pour toute l’image :


CImage *ImgSrc=0,ImgDest;

ImgSrc=new CImage(titre);

ImgSrc->Threashold(3);

ImgSrc->DistanceMorphologique(3) ;

ImgSrc->FindMinimum(true,&ImgMarqueur);

ImgSrc->LPE( [...] ) ;

CImage : est une classe qui contient les opérations de manipulation de l’image comme l’ouverture, la sauvegarde, etc.

III.3.3 L’algorithme proposé

Notre méthode proposée utilise en premier lieu l’algorithme des k-moyennes pour classifier

les pixels de l’image en zones du même niveau de gris.

Cet algorithme se montre non seulement rapide mais donne relativement de bon résultats sur

les images médicales, cependant il ne prend pas en compte le voisinage des pixels, c’est là où

l’algorithme de la LPE intervient pour ajouter la notion de connexité des régions tout en prenant

avantage des centroides des k-moyennes pour les considérer comme des minima. L’organigramme

suivant montre le fonctionnement de la méthode.

53


Etape 1 : K-moyennes

------------------------------------------------------------------------------------------------------------------------

Etape 2 : LPE

III.4 Mise en œuvre

Après avoir exposé les différentes techniques retenues pour la réalisation de notre logiciel et

expliqué les différentes approches adoptées, nous arrivons à présent à la mise en œuvre.

III.4.1 Spécification de l’application

Nous rappelons que le but de notre travail est de d’implémenter l’algorithme de la ligne de

partage des eaux pour la segmentation d’images médicales 3D, nous avons donc baptisé notre

application SEGIM (pour Segmentation des Images Médicales).

54

Oui Non


III.4.2 Outils de Développement

Concernant le langage de programmation, notre choix s’est porté sur le C++ Builder 6, le

langage de programmation C++ est orienté objet, ce qui nous a facilité la tache de développement

en adoptant une organisation en classes de notre application.

III.4.3 Fonctionnalités de l’application

Notre application permet de réaliser les opérations suivantes :

• La détection des contours par la méthode des gradients (Gradient morphologique, Sobel,

Laplace, Prewitt).

• Le filtrage d’une image (filtres morphologiques, filtre médian, moyenneur, … ).

• L’affichage de l’histogramme d’intensité lumineuse.

• La segmentation d’image par LPE

III.4.4 L’interface utilisateur

Les facilités de développement offertes par le C++ Builder nous ont permis de doter notre

application d’une interface utilisateur, simple, intuitive et conviviale.

55


III.5 Matériel et architecture

Le système a été testé sur un ordinateur ayant les caractéristiques suivantes :

• Processeur : Intel dual Core 1.73 GHz.

• Capacité mémoire vive : 3 Go.

• Carte graphique ATI Mobility Radeon HD 2M series 256 Mo de mémoire.

• Disque dur : 180 Go.

III.6 Tests et résultats

Effet des filtres et des opérateurs gradient

T1_x85n T2_x85n Pd_x85n

56


Filtre Moyenneur Filtre Smooth Filtre Médian

Gradient Sobel Gradient Laplacien Gradient Prewitt

Effet des transformations morphologiques

T1_z90n T2_z90n Pd_z90n

57


Erosion Dilatation Ouverture

Gradient morphologique Gradient Interne Gradient Externe

Fermeture Laplacien morphologique Filtre Alterné séquentiel FAS

58


Résultats de la segmentation par LPE

T2_z90n LPE Vincent-SoilleL’application directe de la LPE de Vincent-Soille donne une sur-segmentation. Après un prétraitement on aura un meilleur résultat :

LPE Vincent-Soille améliorée

Résultats de la segmentation LPE par FAH de S.Beucher superposée sur l’image originale :

59


LPE par FAH Notre LPE par FAH

60


Les résultats de notre méthode LPE

Commentaire : le résultat de notre méthode n’est pas complet, faute de temps, l’implémentation

n’est pas achevée au niveau de la deuxième étape de segmentation, alors que la première est réussie

au niveau des K-moyennes.

K-moyennes en trois classes

III.7 Conclusion

Au cours de ce présent chapitre, nous nous sommes étalés sur l’architecture de notre logiciel,

nous avons commencé par donner une vue générale des principaux composants de notre application,

puis les algorithmes implémentés. Nous avons fini par des tests et résultats de notre logiciel sur

différentes images IRM du cerveau humain.

61


62

Documents

Conception, tests et résultats