Richet Coraline Han Xiaofei L3 IUP Informatique 18/12/07

1/53
Richet Coraline
Han Xiaofei
L3 IUP Informatique
18/12/07
SOMMAIRE
1 Présentation du projet................................................................................................................... 2
1.1 Outils mis à
disposition ............................................................................................................................................ 2
2 Mise en œuvre des
fonctions ............................................................................................................................................... 4
2.1 Fonction de
traitement de type Sobel ....................................................................................................................... 4
2.1.1 Algorithme
de calcul du Sobel ................................................................................................................................ 4
2.1.2
Implémentati
on de la fonction de calcul
du Sobel de taille 3 ............................................................................................................................... 5
2.1.3
Implémentati
on de la fonction de calcul
du Sobel de taille
paramétrable ................................................................................................................................. 6
2.2 Fonction de traitement d’érosion ......................................................................................... 8
2.2.1 Algorithme d’érosion ................................................................................................... 8
2.2.2 Implémentation de la fonction d’érosion ..................................................................... 8
2.3 Fonction de traitement de dilatation ................................................................................... 11
2.3.1 Algorithme de dilatation ............................................................................................ 11
2.3.2 Implémentation de la fonction de dilatation .............................................................. 11
Projet
Traitement d'images en C

2/53
2.4 Fonction de traitement ouverture ....................................................................................... 13
2.4.1 Algorithme d’ouverture.............................................................................................. 13
2.4.2 Implémentation de la fonction d’ouverture ................................................................ 13
2.5 Fonction de traitement fermeture ....................................................................................... 14
2.5.1 Algorithme de fermeture ............................................................................................ 14
2.5.2 Implémentation de la fonction de fermeture .............................................................. 14
2.6 Fonction de traitement de filtrage par moyenne ................................................................ 15
2.6.1 Algorithme de filtrage par moyenne .......................................................................... 15
2.6.2 Implémentation de la fonction de filtrage par moyenne ............................................ 15
2.7 Fonction de traitement de segmentation par région (region-growing) .............................. 17
2.7.1 Algorithme de segmentation d’image par région (region-growing) .......................... 17
2.7.2 Implémentation de la fonction de segmentation d’image par région ......................... 18
2.7.3 Implémentation de la fonction de segmentation d’image par région avec un pixel
d’amorce choisi au hasard .......................................................................................................... 22
3 Difficultés rencontrées ............................................................................................................... 23
4 Conclusion ................................................................................................................................. 24
5 Sources du projet ........................................................................................................................ 25
5.1 Fichier traitement.h : .......................................................................................................... 25
5.2 Fichier traitement.C : ......................................................................................................... 26
5.3 Fichier fifo.h : .................................................................................................................... 47
5.4 Fichier fifo.C : .................................................................................................................... 48
5.5 Fichier prog.C : .................................................................................................................. 52
1 Présentation du projet
Le traitement d'images numériques est l'ensemble des techniques permettant de modifier une image
numérique dans le but de l'améliorer ou d'en extraire des informations.
Une image en niveau de gris est un tableau bidimensionnel (matrice) où chaque élément contient une valeur
entre 0 et 255. Par convention, la valeur zéro représente le noir et la valeur 255 le blanc.
000
008
016
024
032
040
048
056
064
072
080
088
096
104
112
120
128
255
248
240
232
224
216
208
200
192
184
176
168
160
152
144
136
L'objectif du projet est de réaliser différents algorithmes de traitement d'images en langage C tels que :
 Sobel : mise en évidence des contours d’une image.
 Erosion et dilatation : supprimer les points de contours isolés ou combler les trous dans un contour
d’une image.
 Segmentation en région : partitionner l'image en zones homogènes.
1.1 Outils mis à disposition
Afin de pouvoir mettre en œuvre ces algorithmes de traitement d’images, des outils ont été mis à
disposition :
 Un dossier IncludeLibImage comprenant :
- Un fichier d’entête image.h définissant une structure de type image et des prototypes de
fonctions (allocation /libération mémoire d’une image, affichage d’une image avec
l’application xv …).

3/53
- Un fichier d’entête xAffichage.h nécessaire à la création d’une fenêtre permettant
d’effectuer des modifications dynamiques en utilisant des touches de clavier.
- Un fichier d’entête LoadSaveImages.h contenant des prototypes de fonctions
d’enregistrement et de chargement d’images.
 Un dossier « XV » contenant les sources compilées du logiciel de traitement d’images XV.
 Un dossier srcImage contenant les sources des fichiers cités ci-dessus.
 Un dossier ExempleTraitement :
- Un fichier traitement.h qui contiendra les prototypes des fonctions de traitement d’images à
implémenter dans le cadre du projet.
- Un fichier traitement.C qui contiendra les implémentations des fonctions décrites dans le
fichier traitement.h.
- Un fichier prog.C qui est le programme principal où sont appelées les fonctions de
traitement d’images et utilisant le logiciel xv.
- Un fichier progX.C qui appelle des fonctions de traitement d’images en utilisant la librairie
Xaffichage.

4/53
2 Mise en œuvre des fonctions
2.1 Fonction de traitement de type Sobel
2.1.1 Algorithme de calcul du Sobel
Il consiste à appliquer un masque sur l’image afin de faire apparaître les endroits de l’image où les
différences entre les pixels voisins sont les plus grandes. Ces différences correspondent au contour de
l’image.
Appliquer un masque sur une image consiste à déplacer sur l’image une fenêtre carrée de taille impair et
supérieur à trois, centré à chaque fois sur un pixel (i,j) dont il faut évaluer le gradient.
Pour chaque pixel de l’image, l’application d’un masque consiste à faire la somme pondérée des valeurs des
pixels voisins de ce pixel.
Exemple de somme pondérée :
Ensuite il s’agit de normaliser cette valeur :
Dv= Dv / somme des coefficients positifs
Pour calculer le gradient en un pixel (i,j), il faut à la fois calculer le gradient vertical (avec un masque
vertical) et le gradient horizontal avec un masque horizontal.
Le résultat du gradient pour le pixel (i,j) est alors :
La valeur calculée est ensuite placée dans le pixel (i,j) d’une image appelée image des gradients.

5/53
2.1.2 Implémentation de la fonction de calcul du Sobel de taille 3
Cette fonction est implémentée en langage C dans le fichier traitement.C :
void basicThreeSobelFunction(const Image * in, Image * out)
Cette fonction permet d'effectuer un traitement Sobel sur une image, à partir d'un masque vertical et
horizontal de taille 3*3.
Le paramètre const Image * in est un pointeur de type Image alloué par l’application faisant appel a cette
fonction.
Le paramètre Image * out est un pointeur de structure de type Image (non alloué) qui permettra de stocker
l’image qui sera traitée.
Pour rappel, la structure de type Image est définie ainsi :
Struct _Image {
int magicNumber ; /* Pour vérifier que on a (pas) alloue de la mémoire */
int nbRow ;
int nbCol ;
octet *ptrZone ; /* Le vrai pointeur sur la zone image */
octet ** zone ; /* Un pointeur qui permet : zone[ligne][colonne] */
} ;
Typedef struct _Image Image ;
Dans cette fonction, les masques vertical et horizontal de taille 3 ainsi que leurs valeurs respectives sont
codées en dur dans la fonction :
masque vertical maskV masque horizontal maskH
L’image donné en paramètre Image * out est allouée par la fonction.
La fonction effectue un parcours de tous les pixels (chaque colonne de chaque ligne) de l’image donnée en
paramètre const Image * in. Pour chaque pixel de coordonnées Xpin et Ypin, la fonction prend en compte les
8 pixels voisins entourant ce pixel et effectue le calcul du gradient vertical normalisé en appliquant le
masque vertical ainsi que le calcul du gradient horizontal normalisé en appliquant le masque horizontal.