Traitement Numerique Des Images

Traitement d'Images 2010 - 2011
TRAITEMENT NUMERIQUE DES IMAGES
EISTI Guy Almouzni

Traitement d'Images 0. Préambule
0. Préambule
Plan du cours
1. Chaîne de vision par ordinateur. Prétraitement - Amélioration d'images
I. CHAINE DE VISION PAR ORDINATEUR
1. Chaîne de vision par ordinateur
2. Domaines d'application du traitement d'images (TI)
3. Configuration matérielle d'un système de traitement d'images
4. Représentation des images
II. PRETRAITEMENT - AMELIORATION D'IMAGES
1. Amélioration et restauration d'images
2. Histogramme d'une image
3. Transformation d'histogrammes (traitement statistique des images)
3.1. LUT
3.2. Recadrage de dynamique
3.3. Binarisation
3.4. Egalisation
2. Filtrage
1. Filtrage - Renforcement du contraste
1.1. Rappels sur le filtrage linéaire 1D
1.2. Renforcement de contraste
1.3. Opérateur Laplacien
1.4. Compléments sur le filtrage 2D
1.5. Opérateur de Chanda
2. Lissage linéaire
2.1. Lissage par la Moyenne
2.2. Lissage Gaussien
3. Lissage non linéaire
3.1. Filtres d'ordre - Opérateur Médian
3.2. Lissage de Nagao
3. Segmentation
1. Segmentation des images en régions homogènes
2. Extraction de contours : approche générale
. Dérivation: ordre 1: Gradient, ou ordre 2: Laplacien
. Maxima du Gradient, ou zero-cross du Laplacien
. Seuillage
3. Performances d'un détecteur de contours linéaire
3.1. Rapport Signal / Bruit
3.2. Unicité de la Réponse
3.3. Localisation
3. Annexe (voir Annexe)
4. Image bi-niveaux - opérateurs morphologiques
1. Images Bi-niveaux
2. Opérateurs Morphologiques
3. Dilatation - Erosion - Squelettisation
3.1. Dilatation
3.2. Erosion
3.3. Squelettisation
3.4. Squelettisation (2)
3.5. Vectorisation
4. Dilatation - Erosion sur des images en niveaux de gris
5. Opérateurs sur images de contours
I. OPERATEURS BAS-NIVEAU
1. Affinage des contours
2. Fermeture des contours
3. Suivi de contours
II. PRIMITIVES DE CLASSIFICATION
1. Etiquetage des régions (Blob Coloring)
2. Approximation polygonale des contours
3. Transformation de Hough
0. 1
Traitement d'Images 0. Préambule
6. Introduction à la Reconnaissance Des Formes (RDF)

0. Description de l'image
1. Descripteur de contour
2. Descripteur de surface
3. Reconnaissance Des Formes et Décision
Application de la Reconnaissance Des Formes :
Système d'identification de Pièces industrielles et de Reconnaissance de l'Ecriture
1. Identification de pièces industrielles
2. OCR : Reconnaissance optique de caractères
2.1. Introduction
2.2. Reconnaissance des caractères scripts
2.3. Réalisations commerciales
6. Annexe (voir Annexe)
ANNEXE
3. Annexe. Nouvelle approche de détection des contours : Critère optimal de Canny - filtre de Deriche
6. Annexe. Reconnaissance d'objets partiellement cachés
. ABC de la vidéo
. Compléments
Bibliographie
[1] H.C. Andrews / B.R. Hunt “ Digital image restoration ” Prentice-Hall

[2] D.H. Ballard / C.M. Brown “ Computer vision ” Prentice-Hall
[3] A. & Y. Belaïd “ Reconnaissance Des Formes ” InterEditions
[4] J. E. Besançon “ Vision par ordinateur ” Eyrolles
[5] K. Castleman “ Digital image processing ” Prentice-Hall
[6] J. Fruitet “ Outils et méthodes pour le traitement des images par ordinateur ” Internet
[7] R.C. Gonzalez / P. Wintz “ Digital image processing ” Prentice-Hall
[8] M. Kunt “ Traitement numérique des signaux ” Dunod
[9] Anil K. Jain “ Fundamentals of digital image processing ” Prentice-Hall
[10] T. Pavlidis “ Structural pattern recognition ” Prentice-Hall
[11] Pratt “ Digital image processing ” Prentice-Hall
[12] J.T. Tou / R.C. Gonzalez “ Pattern recognition principles ” Prentice-Hall
[13] J.J. Toumazet “ Traitement d’images par l’exemple ” Sybex
__________
0. 2
Traitement d'images 1. Chaîne de vision par ordinateur. Prétraitement - Amélioration d’images
1. Chaîne de vision par ordinateur. Prétraitement - Amélioration d’images

L'essor du traitement des images est lié d'une part à l'avènement des robots de 3ème génération (≡ capables de percevoir
et réagir avec l'environnement) et d'autre part à la puissance de calcul que permet le traitement digital.
I. CHAÎNE DE VISION PAR ORDINATEUR
1. Chaîne de vision par ordinateur

Reconnaissance
Image brute
Extraction de Système
Capteur Prétraitement caractèristiques de Réponse
(primitives) Décision
Base de
Connaissances
- Capteur : caméra vidéo, CCD, ... , plaque photosensible aux rayonnnements (Gama, X, ...)
- Prétraitement: amélioration de l'image (renforcement du contraste, réduction du bruit ...)
- Extraction de caractéristiques : contours, régions, angles, segments de droites,...
Les caractéristiques ou primitives sont compatibles avec la représentation qui en est donnée dans la Base de
Connaissances (mémoire).
- Système de Décision : utilise des méthodes de Reconnaissance Des Formes (RDF) communes à d'autres disciplines
(reconnaissance de la parole, ...)
Analogie : le cerveau corrige l’image floue et déformée issue de l’oeil (même chose pour les oreilles !) et effectue
de nombreux prétraitements (occupant ainsi des ressources du cerveau, et, chez les personnes agêes, cette consommation
de ressources peut se faire au détriment de l’attention).
2. Domaines d'application du traitement d'images

3 domaines principaux :
- Imagerie aérienne et spatiale - amélioration des images satellites,
- analyse des ressources terrestres,
- cartographie automatique, analyse météo (Ex. Détection de couverture nuageuse)
Types d'images : caméra dans le visible (couleur (multispectrales) ou N&B (monospectrale)), dans
l’infrarouge (monospectrale), images radars (multispectrales ≡ composées de
plusieurs plans images).
- Technologies biomédicales - images scanner, échographie, RMN
- reconnaissance automatique de cellules ou de chromosomes,
comptage (de cellules par ex.), ostéodensimétrie (ex. prévention de
l’ostéoporose par calcul sur image du taux de calcium osseux), ...
- Robotique - assemblage de pièces, contrôle qualité (ex. identification de code-barre d’une

pièce par traitement d’image), robotique mobile
- stéréorision (3D)
aussi :
- l'astronomie, la chimie, la physique nucléaire (identification de trajectoires de particules), l'armement
(guidage de missiles, Reconnaissance Des Formes)
- la télésurveillance (ex. radar automatique : recherche en temps réel d’un véhicule par reconnaissance de son immatriculation parmi
un flot de véhicules circulant sur le boulevard périphérique par caméra fixe).
1. 1
3. Configuration Matérielle et Logicielle d'un système de traitement d'image

2 types :
1) Contrainte temps réel (ex : reconnaissance d'objets sur une chaîne de montage)
→ Algorithmes implémentés sur circuits câblés ou à la limite sur des processeurs de traitement du signal
(en langage machine) : l'odinateur joue le rôle de superviseur (ordinateur hôte).
2) Pas de contrainte temps réel (ex. : développement, recherche)
→ Algorithmes implémentés sur l'ordinateur : plus lent mais plus souple.
Ecran
graphique
Caméra
analogique
1
Mémoire
Processeur
d'image
Caméra analogique
analogique (Numériseur)
n
Caméra
numérique
1
Processeurs
Caméra numériques
numérique d'images
n
Ordinateur
Imprimante
Mémoire hôte
de
masse
Clavier Ecran
texte
Architecture matérielle d'un système complet de traitement d'image.
1. 2
- Caméra : - Caméra à tube : un faisceau électronique (≡ d’électrons) explore une cible photoconductrice.
Balayage standard : 1/25 ème de seconde pour une image complète.
Image de 625 lignes (balayage télévision) (25 images/seconde)
A chaque ligne correspond un signal analogique proportionnel à l'intensité

lumineuse (luminance).
- Caméra CCD : (Charge Coupled Device) :

assemblage de photodiodes délivrant chacune une intensité proportionnelle à
l'intensité lumineuse d'un point de l'image (pixel).
→ échantillonnage opéré (≠ signal continu fourni par les caméras à tube).
(pas de balayage télévision comme pour les caméras à tube)
Le couple constitué du nombre de pixels en X et en Y est appelé résolution ou
définition.
- Caméra CCD matricielle :

photodiodes disposées en une matrice de n lignes et p colonnes.
Résolutions courantes : NX*NY = 256x256, 320x200, 512x512, 640x480,
800x600, 1024x768.
- Caméra uniligne : (scanner) :

photodiodes disposées en une seule ligne.
Résolution supérieure (2048 points par exemple). L'obtention d'une image implique
le déplacement du scanner (sur un document par exemple) pour avoir une image bi-
dimensionnelle par acquisition de plusieurs lignes.
- Processeur analogique : gestionnaire des entrées-sorties vidéo du système.
Fonctions : - sélection de la caméra active, de l'écran d'affichage

- acquisition du signal vidéo : numérisation (digitalisation) et contrôle de mémorisation/affichage :
numérisation = échantillonnage et quantification (codage)

↓ ↓
découpage en pixels valeur numérique (sur un nombre de m bits)
(échantillonnage spatial) donnée à l'intensité lumineuse par arrondi
→ niveau de gris
Echantillonnage
Contrairement au son pour lequel l’échantillonnage est temporel (période d’échantillonnage de (1 / 44 100)
seconde pour une qualité CD), l’échantillonnage d’une image est spatial :
ex.: image aérienne, image satellite : 1 pixel représente 1 mètre au sol par exemple.
A vitesse V constante, la distance d est directement liée (proportionnelle) au temps t : V = d/t → d = V.t . On peut donc considérer
indifféremment l’image comme un signal spatial (≡ dépendant de la distance) ou temporel (≡ dépendant du temps) et du même coup,
l’échantillonnage peut aussi être considéré indifféremment spatial ou temporel.
Quantification
Codages classiques sur 16, 32, 64, 256 niveaux de gris correspondant respectivement à un nombre m de bits
m = 4, 5, 6, 8.
Ce nombre de niveaux de gris disponibles (2m) s'appelle la dynamique de l'image (à partir de 64 niveaux, l'oeil
ne fait plus beaucoup de différences).
1. 3
- Mémoire d'image (frame buffer)
Image digitalisée = tableau 2D IM de n lignes et p colonnes : IM [0: p-1, 0: n-1] (n,p entiers > 0)
IM[x, y] = niveau de gris du pixel de coordonnées x et y : 0 ≤ x ≤ p-1 0 ≤ y ≤ n-1 (x,y entiers)
IM[x, y] entier codé sur m bits
0 x NX-1
0
X
y
IM[x,y]
NY-1
Image NX : nombre de colonnes (p)
NY : nombre de lignes (n)

Y
L’image peut aussi être mémorisée sous forme 1D : IM [0 : n.p - 1]: les lignes sont stockées bout à bout.
Un calcul d’adresse permet d’accéder à l’index i du pixel (x, y) : i = y. p + x.
En général :
Niveau de gris : 0 → noir

(2m-1) → blanc (255 pour m = 8 bits)
Les mémoire d'images réservent en général : 8 bits (mot standard) pour la dynamique (→ 256 niveaux) ou
24 bits (1 octet par couleur : R (Rouge), V (Vert) ou B (Bleu)
(224 ≈ 16.7 millions de couleurs).
Résolutions courantes : n∗p = 256x256 ou n∗p = 512x512.
(Bon compromis entre la définition de l'image et le temps de
traitement nécessaire).
Elles possèdent en général plusieurs plans mémoire pour traiter
plusieurs images simultanément.
Certaines possèdent des opérateurs intégrés (zoom,
histogramme, opérateurs logiques ...)
- Le Processeur numérique d'images
Processeur(s) câblé(s) ou programmable(s) contenant les algorithmes de traitement. (Temps Réel → temps de
traitement < temps de présence image de 1/25ème de seconde avant l'arrivée de la suivante). (Le traitement
comprend ici l’algorithme mais aussi le chargement et le stockage ou affichage de l’image).
- L'Ordinateur hôte
Il contrôle :
- le processeur analogique
- les échanges mémoire.
Il effectue les traitements s'il n'y a pas de contrainte temps réel.
- Mémoire de masse
Stockage des fichiers images.

Exemple: une image noir et blanc (N/B) 256x256 sur 256 niveaux occupe déjà 64 KOctets !
1. 4
4. Représentation des images

Types d’Images
De nombreux types de format d'image existent, incluant éventuellement une compression des données : formats de
fichier d'extension .BMP de Windows, .TIF , .PCX, .GIF, .JPG (JPEG), .MPG (MPEG) (images animées), ...
Exemple :
Une image en niveaux de gris (≡ monochrome) de taille NX∗NY de dynamique DYN=256 niveaux peut être codée par
un plan mémoire (Bitmap) de NY∗NX octets consécutifs en stockant ligne après ligne l'image.
On peut aussi coder cette image par une table dont chaque case représente non plus directement la luminance d'un pixel
mais un index référant à une palette de niveaux de gris située en tête ou en fin de fichier.
Ces 2 types de codage d’image revêtent le nom d’images mosaïque, ou raster ou encore bitmap. L’objet graphique
élémentaire est le pixel (picture element).
On trouve aussi le format d’images vectoriel pour les images constituées de segments de droites (polygones) (images de
synthèse). Après l’en-tête de fichier, la liste des sommets et leur correspondance est mémorisée. L’objet graphique
élémentaire est le segment. Le format d’images vectoriel est l’équivalent du format midi pour la synthèse de la musique,
et le format bitmap d’images d’acquisition, l’équivalent du format wav pour l’acquisition de musique.
Pour les images couleur (≡ multispectrales), il en est de même :
Index sur une palette de couleurs ou codage Bitmap non plus du niveau de gris mais de 3 luminances pour chaque pixel :
niveau de Rouge, niveau de Vert et niveau de Bleu (codage RVB) ou des 3 informations équivalentes : Teinte,
Saturation, Luminosité (codage ILS), ...
En traitement d'images, l'objectif ultime est la Reconnaissance Des Formes: pour cela, on réalise des prétraitements
d'amélioration et ensuite on s'attache à ne retenir que les informations nécessaires à la compréhension de l'image pour se
donner une représentation minimale de l'image, apte à permettre la reconnaissance (extraction des contours ...).
Autant dire que l'image brute en niveaux de gris et à fortiori en couleurs est trop riche en informations (il y en a trop !).
On peut quasiment toujours comprendre une image sans avoir tout le flot d'informations présentes dans une image en
niveaux de gris ou en couleurs (la compréhension est souvent une réduction d’informations).
On veillera à ne retenir que les informations pertinentes de l'image et à les insérer dans une structure adaptée à sa
reconnaissance.
Voilà pourquoi on ne travaillera pas avec des images couleur mais des images en niveaux de gris. (Il faudrait 3 fois plus
de traitement sans pour autant aider de façon notable la reconnaissance).
La conversion d'une image couleur RVB en niveaux de gris N/B se fait par la relation issue de la colorimétrie :
Niveau de gris = 30%∗R + 59%∗V + 11%∗B.
Les images utilisées en Travaux Pratiques sont donc en niveaux de gris et codées avec le format bmp.
Sauf indication contraire, tous les exemples donnés dans ce qui suit feront référence à une image IM[0:255,0:255] codée
sur 256 niveaux de gris (0 → 255), dont le nombre de colonnes est noté NX et le nombre de lignes NY.
Caractéristiques principales des images raster

Une image rectangulaire bitmap est caractérisée par :
• le nombre de colonnes NX de l’image
• le nombre de lignes NY
• la dynamique (nombre de bits par pixel) : le nombre de niveaux de quantification varie de 2 (noir ou blanc des
dessins « au trait » des scanners), à 256 par composante de couleur (256 niveaux de Rouge, 256 niveaux de Vert, 256 niveaux de
Bleu) (ou 256 niveaux de gris pour les images monochromatiques → 8 bits par pixel).
• la résolution spatiale (nombre de pixels par unité de surface, indiquant ainsi la distance que représente 1 pixel).
La résolution spatiale d’une image bitmap est l’équivalent du taux d’échantillonnage temporel (fréquence
d’échantillonnage) d’un fichier audio non synthétique (format type wav/mp3 …).
Sur un écran d’ordinateur, la résolution spatiale est d’environ 75 dpi ou ppp (dot per inch, point par pouce), meilleure
que la télévision (environ 25 dpi pour un écran télévision de 50 cm). La résolution spatiale passe à 300 dpi pour une
imprimante (et à une dizaine de milliers de dpi pour une diapositive). Le satellite SPOT fournit des images
correspondant à une distance au sol de l’ordre de la dizaine de km. Les meilleurs satellites américains peuvent descendre
à une résolution spatiale de l’ordre du cm.
Une résolution de 300 dpi correspond à un pixel de 85 µm de côté (1 pouce = 2.54 cm).
1. 5
Numérisation des signaux analogiques vidéo

Les signaux analogiques vidéo peuvent être de nature différente :
• les signaux primaires R,V,B (disponibles sur prise Péritel, SVGA (≡ VESA))
• les signaux à composantes, séparant la luminance (Y) de l’information de couleur (chrominance C) (prise S-Vidéo,
S-VHS, disponibles sur prise Péritel) (qualité moindre par rapport aux signaux R, V, B)
• les signaux composites, où luminance et chrominance sont codées sur un signal unique (prise RCA de sortie vidéo
des cartes vidéo des ordinateurs) (qualité moindre par rapport aux signaux à composantes)
La résolution des images vidéo dépend du nombre de lignes permettant le balayage d'une image complète. Elle est de
625 lignes pour les normes de codage de la couleur PAL et SECAM, dont seulement 575 sont visualisées. Pour
accélérer l'affichage, le balayage est entrelacé : la première trame correspond aux lignes impaires (1/50 ème de seconde),
la deuxième trame aux lignes paires. Une image est donc rafraichie tous les 1/25 seconde.
La numérisation en temps réel suppose que l'opération puisse être effectuée en 1/25 seconde, ce qui impose pour un
débit de 200 KO/s de comprimer fortement les données et de réduire la taille de l'image (320x200) pour respecter la
cadence de 25 images par seconde. Dans le domaine du multimédia, de gros progrès ont été réalisés récemment pour
fournir des séquences vidéo numérisées très compactes (norme MPEG-4, DivX).
L’interface graphique SVGA

VGA (pour Video Graphic Array) est une norme matérielle pour les cartes graphiques sur PC et compatibles IBM
aujourd'hui obsolète. Elle est remplacée par la norme VESA dite aussi SVGA. Les cartes SVGA équipées de 512 ou
1024 Ko de mémoire vidéo peuvent afficher de 256 à 32000 et même 16 106 couleurs en 1024x768, 800x600 ou
640x480 sur des moniteurs analogiques multisynchrones.
Perception des couleurs

C'est par la lumière que la couleur existe. Elle ne réside pas dans les objets mais dans la lumière qui les éclaire et dans
leur propriété à absorber certaines radiations tout en en réfléchissant d'autres.
La perception des images formées sur la rétine de l'oeil repose sur deux types de récepteurs : les cônes et les bâtonnets.
Les bâtonnets, dont la sensibilité est environ 500 fois plus grande que celle des cônes, assurent la vision scotopique
correspondant au faible éclairement nocturne, tandis que les cônes assurent la vision photopique, correspondant à
l'éclairement diurne.
La rétine est sensible aux rayonnements électromagnétiques de longueur d'onde comprise entre 380 et 700 nm. Les
études de trois espèces de cônes et les phénomènes complexes qui permettent de percevoir les sensations colorées
aboutissent à dire que l'oeil n'est sensible qu'à trois plages de radiations ayant leur maximum vers 450 nm (bleu), 525 nm
(vert) et 625 nm (rouge). Les multiples sensations colorées sont le résultat de l'excitation plus ou moins intense de nos
trois espèces de cônes à ces trois radiations, interprétées par notre cerveau.
Notre oeil est capable de discerner 350 000 couleurs et d'en reconnaître 128.
La nature trichrome de la perception des couleurs permet de recréer n'importe quelle couleur par un mélange de trois
couleurs primaires : rouge, vert, bleu.
1. 6
Synthèse additive
La synthèse additive consiste à restituer une couleur par addition de trois sources lumineuses rouge, vert, bleu (RVB)
[RGB: red, green, blue]. Ce procédé est utilisé dans les tubes cathodiques couleur.
Synthèse soustractive
La synthèse soustractive permet de restituer une couleur par soustraction, à partir d'une source de lumière blanche, avec
des filtres correspondant aux couleurs complémentaires : jaune, magenta, cyan. Ce procédé est utilisé en photographie et
pour l'impression des couleurs.
Dans un système de référence RVB, une couleur C est définie par ses trois composantes :
C = rR + vV + bB
r, v, b représentant les quantités de chaque couleur dans une échelle appropriée 0-100 (ou 0-255 pour une quantification
sur un octet par composante...).
De la même façon on peut définir une couleur dans le système de référence complémentaire (Cyan, Magenta, Jaune) :
C = cC + mM + jJ
Le passage d'un système à l'autre se fait par les relations : c=100-r ; m=100-v ; j=100-b.
Représentation ITS de Munsell

A côté de ces systèmes de référence utilisés couramment en télévision et en impression, d'autres systèmes ont été
proposés, se rapprochant de la description habituelle des couleurs dans les arts graphiques, car basés sur des expériences
visuelles d'appréciation des couleurs. L'un des plus répandus est le système de Munsell (1929) qui repose sur trois
composantes : l'intensité, la teinte et la saturation. Chaque couleur est définie dans cet espace tridimensionnel par ses
coordonnées cylindriques.
Intensité
L'intensité ou luminance [intensity, value, luminosity] est le caractère qui indique l'intensité de lumière perçue
indépendamment de la couleur. Elle s'étend du noir au blanc avec toutes les nuances de gris si on ne voit pas la couleur.
Teinte
La teinte [hue] est le caractère qui indique la dominante de couleur perçue. La teinte est généralement ordonnée en
longueurs d'ondes croissantes du violet au rouge, à la périphérie du cylindre, dans l'ordre du spectre, et définie par un
paramètre angulaire. Le noir, le blanc et les gris n'ont pas de teinte ; cette composante reste indéterminées pour ces
couleurs.
Saturation
Ce caractère exprime la quantité de lumière blanche qui s'ajoute à la teinte dominante. La saturation [saturation,
chroma] d'une couleur est d'autant plus grande que la proportion de lumière blanche est faible. Cette composante est
nulle pour toutes les teintes de gris qui n'ont pas de couleur dominante.
1. 7
Système HLS (Hue, Saturation, Ligthness) et HSV (Hue, Saturation, Value)

Ce système dérivé de celui de Munsell est adapté au calcul informatique. On le trouve dans la plupart des logiciels de
colorisation d'images et de 'retouche photographique'.
L'espace HLS est représenté par un double cône dont la base est commune.
Hue
La position angulaire d'une couleur correspond à sa teinte et se situe sur la périphérie du cône pour les couleurs
monochromatiques. Les 6 principales valeurs angulaires sont rouge 0deg., vert 120deg., cyan 180deg., bleu 240deg.,
magenta 300deg., rouge 360/0deg..
Lightness / Value
Les coordonnées verticales sur l'axe central quantifient la luminance, depuis la pointe du cône inférieur pour le noir
jusqu'à la pointe du cône supérieur pour le blanc.
Saturation
La distance par rapport à l'axe central indique la valeur de la saturation, décroissant de la périphérie vers le centre.
Formats des fichiers images

Les formats de fichiers images sont nombreux et incompatibles. Ils sont souvent liés à un producteur de matériel (Hewlett
Packard : format HPGL), de logiciel (Adobe : format Postscript ; DeLuxePaint : format LBM) ou une norme graphique
(TIFF).
Principaux formats de données images
Type Extension Nom Spécificité - Domaine
Vecteur PS Postscript (Adobe) Lang. description de page
HPGL Hewlett Packard Graphic Langage interprété ;
DRW Language Micografx Drawing CAOArts graphiques
WMF Windows Meta File
DXF Autocad Arts graphiques CAO DAO
Bitmap EPS Encapsulated Postscript Bitmap encapsulé dans Postscript
GIF Graphic Information Format(ATT) Comprimé LZW
IFF Interchange File Format Comprimé RLE
TIFF Tagged Image File Format Pour images bitmap 256 (256x256x256 couleurs)
PCX Paint Brush - Zsoft Format vieillissant...
BMP BitMap Windows Format des images Windows Microsoft
PICT Bitmap Apple Apple Macintosh
JPEG Joined Picture Graphic Compression(DCT par blocs/ondelettes (JPEG2000))
Video MPEG Motion Picture Graphic Vidéo avec compression inter-images (MPEG2)
DV Digital Video (camescopes) Vidéo avec compression intra-images
AVI Audio Video Interlaced Vidéo compressée via codecs (DivX (MPEG4)
Organisation d'un format graphique bitmap : entête + données
Un fichier graphique est en général constitué deux parties :

• une en-tête contenant les informations nécessaires à la reconstitution de l'image.
Informations indispensables : largeur de l'image en pixels, hauteur en nombre de lignes, nombre de bits pour coder un
pixel. Informations supplémentaires éventuelles : type de codage, numéro de version et signature du logiciel, abscisse et
ordonnée d'origine à l'écran, palette de couleurs, etc.
• les données de l'image proprement dites.
1. 8
Traitement d’Images
Le traitement d'image consiste à améliorer le contenu d'une image pour en extraire de l'information : par exemple
identifier une séquence de texte [OCR - Optical Character Recognition] ou un chromosome, éviter un obstacle
(robotique), détecter des zones soumises à l'érosion (télédétection). En bref traiter une image c'est lui ajouter du sens par
un procédé automatique.
Pour cela il peut être nécessaire de supprimer les facteurs de bruit, de rehausser les signaux utiles contribuant à une
meilleure lisibilité. Nous examinerons donc différentes transformations. Certaines affectent tout (ou partie) des pixels de
l'image sans qu'intervienne la notion de position spatiale des pixels, ce sont des transformations globales. Les opérations
entre images permettent de traiter des séries d'images relatives à la même scène. Enfin des opérations plus élaborées,
dites de convolution, portent sur plusieurs pixels voisins et ont donc un caractère local.
Etapes de l’analyse d’images
La plupart des applications de traitement d'image passent par les étapes suivantes :
• Acquisition : Echantillonnage, Quantification
• Analyse globale de l'image et transformations ponctuelles : Histogramme; Statistiques : moyenne, écart-type,
etc... Transcodage (palette de couleur [LUT]) et classification
• Opérations entre images : Indices, ratio; Différence; Opérations logiques, masques; Seuillage
• Amélioration, filtrage et segmentation : Anamorphose (≡ recadrage de dynamique); Opérations de convolution :
Lissage, Rehaussement, Détection de contours; Squelettisation; Vectorisation
• Interprétation et sémantique : Cartographie thématique : classification automatique et supervisée; Cartographie
vecteur; Représentation des graphes et de la topologie.
Exemples d’opérations sur images
Si on dispose de plusieurs images de la même scène, on peut appliquer une fonction sur deux images ou plus, afin d'en
extraire des informations significatives :
Ns = f(Ne1, Ne2,Ne3...)
Le domaine de variation de la fonction est en général différent du domaine de variation de la variable. Le niveau de gris
en sortie (Ns) peut donc être inférieur à 0 ou supérieur à 255. On peut alors soit ramener toutes les valeurs à cet
intervalle en tronquant celles qui en sortent, ce qui fait perdre de l'information, soit normaliser la fonction par une
transformation linéaire.
Différence de deux images

La différence entre l'image d'un objet et l'image du fond permet d'isoler directement cet objet. Cette technique s'applique
aussi à deux images correspondant à deux positions du même objet.
La différence de deux images d'une balle de ping-pong permet de calculer son déplacement (noter les ombres en bas de
l'image).
Division d'images
Cette opération est utilisée en télédétection pour calculer le ratio entre deux canaux, qui est plus facile à interpréter que
les canaux d'origine. Ainsi le ratio entre le canal infrarouge et le canal vert du satellite SPOT est un indicateur de
transparence de l'eau.
Opérations logiques
Ces opérations s'appliquent souvent à des images binaires mais elles sont quelquefois étendues à des images
quelconques. Un masque étant défini comme une image ne contenant que des pixels à 0 ou 255, son application
s'effectue par un ET logique entre le masque et l'image correspondante. La création d'un masque peut être effectuée par
le seuillage d'une image. Cette technique est utilisée en télédétection pour isoler les étendues couvertes d'eau car leurs
valeurs radiométriques sont très faibles dans les canaux infrarouge. Un masque peut aussi être défini par une forme
géométrique dessinée sur l'image ou définie a priori. L'application d'un masque permet aussi de traiter séparément deux
zones distinctes de l'image puis de les regrouper par une addition après traitement.
1. 9
Opérations entre images

Si on dispose de plusieurs images de la même scène, on peut appliquer une fonction sur deux images ou plus, afin d'en
extraire des informations significatives :
Ns = f(Ne1, Ne2,Ne3...)
Le domaine de variation de la fonction est en général différent du domaine de variation de la variable. Le niveau de gris
en sortie (Ns) peut donc être inférieur à 0 ou supérieur à 255. On peut alors soit ramener toutes les valeurs à cet
intervalle en tronquant celles qui en sortent, ce qui fait perdre de l'information, soit normaliser la fonction par une
transformation linéaire.
Différence de deux images

La différence entre l'image d'un objet et l'image du fond permet d'isoler directement cet objet. Cette technique s'applique
aussi à deux images correspondant à deux positions du même objet.
La différence de deux images d'une balle de ping-pong permet de calculer son déplacement (noter les ombres en bas de
l'image).
Division d'images
Cette opération est utilisée en télédétection pour calculer le ratio entre deux canaux, qui est plus facile à interpréter que
les canaux d'origine. Ainsi le ratio entre le canal infrarouge et le canal vert du satellite SPOT est un indicateur de
transparence de l'eau.
Opérations logiques
Ces opérations s'appliquent souvent à des images binaires mais elles sont quelquefois étendues à des images
quelconques. Un masque étant défini comme une image ne contenant que des pixels à 0 ou 255, son application
s'effectue par un ET logique entre le masque et l'image correspondante. La création d'un masque peut être effectuée par
le seuillage d'une image. Cette technique est utilisée en télédétection pour isoler les étendues couvertes d'eau car leurs
valeurs radiométriques sont très faibles dans les canaux infrarouge. Un masque peut aussi être défini par une forme
géométrique dessinée sur l'image ou définie a priori. L'application d'un masque permet aussi de traiter séparément deux
zones distinctes de l'image puis de les regrouper par une addition après traitement.
Les domaines d’application du Traitement d’Images
On peut distinguer trois grandes classes d'applications faisant appel au traitement d'image
- la retouche des images photographiques, les arts graphiques, les applications multimédia, pour lesquels les logiciels
Photoshop sur Macintosh et ImageIn sur PC sont la référence,
- la reconnaissance de forme, la reconstruction 3D et la vision en robotique,
- le contrôle non destructif (identification et/ou comptage de cellules dans un tissu biologique, détection de mal-façons
sur des pièces mécaniques), l'analyse de matériaux et de surfaces, l'imagerie médicale, la télédétection, etc.
Logiciels de Traitement d’Images
Dans les domaines techniques et scientifiques les logiciels spécialisés sont légion. Sur station de travail sous Unix,
Khoros est un logiciel du domaine public très complet. Sur PC le logiciel didactique Titus convient à l'initiation au
traitement d'image satellite ; il est disponible auprès du GDTA. PhotoFinish et PaintShopPro sont des shareware sous
Windows. GraphicConverter est aussi un très bon shareware sur Macintosh. Ces outils disposent de fonctions
élémentaires de traitement d'image qui suffisent dans la plupart des cas pour l'initiation et l'utilisation en classe. Par
contre l'effet de tel ou tel filtre n'est pas toujours évident ; c'est par essai et erreur qu'on finit (ou pas !) par obtenir un
résultat acceptable.
Outil de développement pour les Travaux Pratiques
De nombreux logiciels de traitement d'images existent dans le domaine professionnel et grand public sur PC / MacIntosh
/ Stations de travail / Mini et Gros systèmes :
(Visilog, Image-in, PhotoStyler, PhotoShop, Paint Shop Pro ... sur PC).
1. 10
Pour les Travaux Pratiques, on dispose de logiciels spécifiques permettant de développer ses propres opérateurs (≡ filtres)
:
- TurboPascal sous DOS: Répertoire de travail : C:\TEMP comme copie de \CORRIGES\GA\TI\TIP
- TurboC sous DOS: Répertoire de travail : C:\TEMP comme copie de \CORRIGES\GA\TI\TIC
- BorlandC++ sous Windows: Répertoire de travail : C:\TEMP comme copie de \CORRIGES\GA\TI\TIWBC
- LabWindows/CVI sous Windows: Répertoire de travail : C:\TEMP comme copie de \CORRIGES\GA\TI\TIWCVI
- VisualC++ sous Windows: Répertoire de travail : C:\TEMP comme décompactage de \CORRIGES\GA\TI\TIWVC
- Mathcad sous Windows: Répertoire de travail : C:\TEMP comme copie de \CORRIGES\GA\TI\TITPx
Répertoire de stockage des images : décompactage de \CORRIGES\GA\TI\ImBmp.exe
Exemples d’Images
Exemples d'images : Bato.bmp (source: CNRS) et Coco.bmp :
Bato.bmp (NX*NY*DYN = 256*256*256 ) Coco.bmp (147*195*256)
1. 11
II. PRETRAITEMENT - AMELIORATION D'IMAGES
1. Amélioration et restauration d'images

Bruits présents dans l'image : - suréclairage ou sous-éclairage
→ saturation ou mauvais rapport S/B de la caméra.
- distorsions optiques : aberrations, astigmatisme,
problèmes de prise de vue : mise au point.
- bruit électronique lié au capteur (bruit thermique des composants).
- défauts du système de numérisation.
- Restauration (image restoration)
Restitution de l'image aussi proche que possible qu'avant dégradation.

→ détermination du modèle mathématique du processus de la dégradation (Fonction de Transfert 2D: FT 2D: H(u,v)),
et application du modèle inverse ( 1/H(u,v) ) sur l'image.
Détermination de 2 manières: à priori et à postériori :
- à priori : modèle H(u,v) construit à partir d'images tests (identification):
im[x,y] Restauration wm[x,y] TEMPS
-1
TF2D TF2D
IM[u,v] 1/H(u,v) WM[u,v] FREQUENCE
Inconvénient : H(u,v) peut être nul dans un domaine et le filtre inverse 1/H(u,v) est indéterminé ou instable.
On préfère alors déterminer la Réponse Impulsionnelle (RI) du filtre qui minimise l'erreur (critère de moindres carrés)
entre l'image restaurée et l'image non dégradée (filtrage optimal). De plus, les paramètres du filtre évoluent
dynamiquement pour adapter la restauration (filtrage adaptatif): c'est la méthode à postériori:
- à postériori (filtre adaptatif) : restauration à l'aide de mesures réalisées sur l'image à restaurer, selon un processus
adaptatif. Ces méthodes sont lourdes et encore peu utilisées à cause de leur coût élevé en temps calcul, et de la nécessité
de la connaissance du processus de dégradation.
Exemple : Restauration d’une image dégradée à cause du « bougé » du photographe lors de la prise de vue. La
dégradation se traduit par un flou et une traînée sur l’image, la rendant « illisible ». La modélisation (direction, vitesse)
du bougé autorise la restauration de l’image en appliquant la transformation inverse :
Image dégradée Image restaurée
- Amélioration d'images (image enhancement) :

Prétraitements visant à atténuer les bruits dans l'imagesans nécessiter la connaissance du modèle de la dégradation.
Différentes approches : - à partir de l'histogramme de l'image (méthode statistique).
- par lissage : - linéaire (filtrage linéaire)
- non linéaire
1. 12
2. Histogramme d'une image (traitement statistique de l’image)

But : L'histogramme des niveaux de gris d'une image donne la fréquence d’apparition
(≡ population) de chaque niveau de gris dans l'image :
Inconvénient du traitement statistique : Perte de l’information de localisation.
Avantage du traitement statistique : Traitement global.
Population
Nombre de pixels
de niveaude gris
NG
Niveau de gris
0 NG 255
Histogramme Histogramme
0 255 0 255
Sous-éclairage Sur-éclairage
Histogramme Image de la
bi-modal scène
Objets Fond 255
Valeur à choisir pour le seuil de binarisation
1. 13
Algorithme du calcul de l'Histogramme d'une image de taille NX*NY et de dynamique D :

Début
Mise à zéro des D éléments du vecteur Histo ;
Pour tout point [x,y] de l'image IM Faire
Histo [ IM [x,y] ] : = Histo [ IM [x,y] ] + 1 ; ou n : = IM [x,y];
Histo n : = Histo n + 1 ;
Fp
Fin
L'itération : "Pour tout point [x,y] de l'image IM" consiste en un Balayage de l'image
par exemple horizontal (ligne par ligne d'image), de haut en bas et de gauche à droite :
Pour y = 0 à NY-1 Faire

Pour x = 0 à NX-1 Faire
Fp
Fp
3. Transformations d'histogrammes
3.1. Table de conversion : LUT : Look Up Table
LUT : fonction qui transforme un niveau de gris i en un niveau de gris j, sans modification spatiale de l'image.
But : Elle permet de gagner du temps calcul.
(Les calculs sont effectués une fois pour toutes et mémorisés dans la LUT - on applique alors le transcodage (simple
lecture d'un vecteur : le vecteur LUT) ).
Exemple :
Niveau de gris final
Nf
Niveau de gris initial

0 i Ni
accentuation de l'éclairage des zones de faible luminance
1. 14
Algorithme utilisant une LUT :

Début
Calculer initialement et une fois pour toutes la LUT : Constitution del la LUT : for i = 0 to 255 LUT[i] = 255-i
Pour tout point [x,y] de IM Faire
IM [x,y] : = LUT [ IM [x,y] ] ; /* l'image de départ IM est modifiée */
ou
WM [x,y] : = LUT [ IM [x,y] ] ; /* l'image de départ IM n'est pas modifiée */
Fp
Fin
Exemple : LUT d'inversion vidéo :
i 0 1 2 ... 254 255

LUT [i] 255 254 253 ... 1 0
Inversion vidéo sans LUT : (inversion vidéo algorithmique)

Début
IM [x,y] : = 255 - IM [x,y] ; /* l'image de départ IM est modifiée */
ou
WM [x,y] : = 255 - IM [x,y] ; /* l'image de départ IM n'est pas modifiée */
Fp
Fin
≡ Anamorphose)
3.2. Recadrage de Dynamique (≡
But : Faire de telle sorte que l'image occupe toute la dynamique, pour accroître la séparation (précision) des luminances
(amélioration du contraste de l’image).
Histogramme recadré : toute la dynamique est occupée
Min Max Fonction de recadrage
Histogramme initial
1. 15
Algorithme de recadrage de dynamique (sans perte de points aux bords) :
Début
Delta : = 255 / (Max - Min) ; L'image ainsi que
que l'histogramme
Pour tout point [x,y] de IM Faire sont recadrés
WM [x,y] : = ( IM [x,y] - Min ) * Delta ;
Fp
Fin
Une variante de cet algorithme consiste à supprimmer un pourcentage donné d'éventuels

points aux bords de l'istogramme ( = points de niveau de gris très faible ou très élevé),
souvent isolés, et qui gênerait le recadrage de dynamique précédent.
≡ Seuillage d'image)
3.3. Binarisation d'image (≡
But : Réduction importante de la quantité d'information (l'image résultat est codée sur 2 niveaux → dynamique réduite à 2 :
image bi-niveaux).
L'image reste compréhensible dans la plupart des cas.
1 seuil
Algorithme de Binarisation à 1 seuil :
Début

si IM [x,y] > seuil alors WM [x,y] : = 255 sinon WM [x,y] : = 0
Fp
Fin
Le seuil peut être choisi de façon statistique par utilisation de l'histogramme

(ex.: caractère bimodal de l'histogramme,...)
1. 16
2 seuils
Algorithme de Binarisation à 2 seuils :
Début
si IM [x,y] > seuil1 et IM [x,y] < seuil2 alors WM [x,y] : = 255
sinon WM [x,y] : = 0
Fp
Fin
Résultat du seuillage (1 seuil) :
Image initiale (vertebre.bmp) Image seuillée (seuil = 110)
3.4. Egalisation d'Histogramme (Réhaussement d'image)
Problème : l'image naturelle quantifiée de manière linéaire présente une majorité de pixels de luminance < luminance
moyenne : les détails dans les régions sombres sont difficilement perceptibles.
But : augmenter la dynamique pour les niveaux de gris faibles sans en perdre sensiblement pour les niveaux élevés.
(L’amélioration du rapport Signal/Bruit transforme la quantification linéaire en une quantification exponentielle →
compression logarithmique).
→ égalisation : modification de l'histogramme (et aussi de l'image) pour qu'il soit uniforme (population constante pour
tous les niveaux de gris).
(On peut généraliser à une modification telle que la forme de l'histogramme soit exponentielle, logarithmique...)
L'idée est de modifier la répartition des niveaux pour obtenir un histogramme plat étendu à l'ensemble des valeurs
possibles. Dans cette opération la dynamique originale [min,max] est étalée à [0,255]. On cherche à affecter le même
nombre de pixels à chaque niveau de gris ; c'est pourquoi on appelle cette opération équipopulation. L'effet obtenu
permet de mieux séparer les valeurs les plus représentées dans l'image et de rapprocher les valeurs marginales.
Cela a pour effet d'améliorer le contraste de l'image. Cette transformation peut aussi être appliquée pour réduire le
nombre de niveaux pour la visualisation ou pour l'impression (passer de 256 à 16 niveaux) ; elle s'apparente alors à une
classification puisqu'il s'agit de représenter plusieurs valeurs initiales par la même valeur finale.
1. 17
Soit une image de taille p x p ayant NI niveaux ( ex: image 256x256 sur 256 niveaux) :
Population
Niveau de gris
p
2
Image initiale de dynamique NI comptant p pixels: p Histogramme: 0 255
N niveaux
I
L'histogramme égalisé doit être constant.

On pourrait imaginer cette constante égale à p2/NI car on a bien alors (p2/NI )* NI = p2 , mais on n’a aucun moyen
d’action pour y arriver à priori. L’idée consiste alors à diminuer le nombre de niveaux de dynamique : NI → NF
( < NI ) et à cumuler les populations correspondantes pour tendre vers la Cte p2/NF .
On choisit donc de coder l'histogramme égalisé (et l'image résultat) sur NF niveaux avec NF < NI (égalisation ≡ intégration).
En général, on prend NF = NI /2 qui effectue l'intégration minimale (pour une intégration plus importante, on peut
réitérer cette égalisation minimale plusieurs fois).
Le nombre de pixels pour chaque niveau de l'histogramme égalisé idéal est constant et égal à p2/NF :
Population
2 Niveau de gris
p /N
p F
Image de dynam. NF de p2 pixels: p Histogramme égalisé: 0 255

N niveaux
N /N F
I F
→ L'histogramme final est séparé en bandes de taille NI / NF .
L'égalisation procède ainsi, à partir de l’histogramme initial :

- on part du niveau de gris 0 et on calcule le cumul de la population ayant les niveaux de gris suivants (0, 1, 2 ...) dans
l'histogramme original jusqu'à ce que cette somme soit le plus proche de la valeur moyenne idéale p2/NF.
- tous les niveaux de gris de l' histogramme initial qui ont contribué à cette somme sont alors recadrés sur un niveau de
gris final unique situé au centre de ce qui constitue la 1ère bande de l'histogramme final. L’image initiale est modifiée en
conséquence : tous les pixels ayant un niveau de gris ayant contribué à la somme en question sont ramenés à ce niveau
final unique.
- on itère ce processus pour les bandes suivantes.
Exemple :
Histogramme initial
p2 / N
F
p2 / N
I
N I niveaux
0 1 2 3 4 5 6 7 8 9 10 11
Histogramme égalisé (quasi-idéal)

(N = N / 2)
F I
p2 / N Les niveaux sont pris de 2 en 2
F
pour garder la même dynamique
que l'image initiale.
0 1 2 3 4 5 6 7 8 9 10 11 N niveaux Bandes de largeur : N / N
F I F
1. 18
Algorithme d'égalisation d'histogramme :
IM : image à égaliser
Histo : histogramme de l'image
Transfo : table d'égalisation entre image originale et finale
iDébut : pointe le début de la zone d'intégration sur Histo
iFin : pointe la fin de cette zone
Bande : largeur de bande finale :N I / N F
CentreBande : pointe sur le centre de la bande courante, initialisé à Bande/2
Début
NF N I/ 2
Moyenne p *. p / N
F
Bande N I / NF
CentreBande Bande / 2
iDébut 0; iFin 0
Tant que iFin < N I Faire
Cumul 0
Tant que Cumul n'est pas proche de Moyenne et iFin < N I Faire
Cumul Cumul + Histo [iFin]
Incrémenter iFin
Ftq
Pour i = iDébut à iFin -1 Faire

Transfo[i] CentreBande
Fp
iDébut iFin
CentreBande CentreBande + Bande
Ftq
Pour tout point [x,y] de l'image IM Faire
IM [x,y] Transfo [ IM [x,y] ]
Fp
Fin
__________
1. 19
Traitement d'Images TP 1. Chaîne vision. Prétraitement
TP 1. Chaîne de vision. Prétraitement
1. Traitement d'images 2D et 1D N&B

Lecture N&B :
I := READ_IMAGE( "vertebre.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 69 Ny = 138
Exemple : inversion vidéo d'une image

Traitement 2D T2D( I) := for y ∈ 0 .. rows( I) − 1
for x ∈ 0 .. cols( I) − 1
J ← 255 − I
y, x y, x
J
J := T2D( I)
Traitement 1D (colonne) T1DColonne( I , f ) := for n ∈ 0 .. rows( I) − 1 T1D( I) := for x ∈ 0 .. cols( I) − 1

g ← 255 − f 〈x〉
n n f ←I
g 〈x〉
J ← T1DColonne( I , f )
return J
K := T1D( I)
Image originale Image inversée vidéo 2D Image inversée vidéo 1D
I J K
TP 1. 1
2. Traitement d'images 2D couleur

Lecture N&B :
I := READ_IMAGE( "mandril.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 200 Ny = 290
Exemple : inversion vidéo d'une image :
Traitement 2D N & B T2D( I) := for y ∈ 0 .. rows( I) − 1

for x ∈ 0 .. cols( I) − 1
J ← 255 − I
y, x y, x
J
J := T2D( I)
Lecture Couleur :
cols( C)
C := READRGB( "mandril.bmp" ) Nombre de colonnes : Nx := Nombre de lignes: Ny := rows( C)
3
rC := submatrix C , 0 , rows( C ) − 1 , 0 , − 1

cols( C) Nx = 200 Ny = 290
 3 
gC := submatrix C , 0 , rows( C) − 1 , − 1 
cols( C ) cols( C)
, 2⋅
 3 3 
bC := submatrix C , 0 , rows( C) − 1 , 2 ⋅ − 1
cols ( C ) cols ( C )
, 3⋅
 3 3 
Traitement 2D Couleur
rK := T2D( rC)
gK := T2D( gC) rC gC bC
bK := T2D( bC)
TP 1. 2
Image originale Couleur Image inversée vidéo N&B Image inversée vidéo Couleur
rC , gC , bC J rK , gK , bK
3. Zoom avant et arrière x2 Zoom xcoeff quelconque

I := READ_IMAGE( "cub.bmp" ) Nombre de colonnes : Nx := cols( I) Nx = 75 Nombre de lignes :Ny := rows( I) Ny = 120
ZoomX2( I) := ZoomSur2 ( I) := ZoomX( I , coeff ) :=
Z := ZoomX2( I) L := ZoomSur2 ( I) M := ZoomX( I , 0.9)

Image originale Image Zoomx2 Image Zoom/2 Image ZoomX
I L M
TP 1. 3
4. Histogramme d'une image

I := READ_IMAGE( "bato2.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 128 Ny = 128
Histo( I) :=
H := Histo( I) ng := 0 .. 255
Image originale Histogramme
240
Hng
0 ng 255
TP 1. 4
5. Recadrage de dynamique d'une image (sans perte de points aux bords)

Lecture N&B :
I := READ_IMAGE( "aquitai2.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 128 Ny = 128
H := Histo( I)
3
1.276⋅ 10
RecadrageDyn( I) :=
H ng
0 ng 255
R := RecadrageDyn( I)
H := Histo( R )
3
1.276⋅ 10
H ng
0 ng 255
Image originale Image de dynamique recadrée
TP 1. 5
6. Binarisation d'une image

Lecture N&B :
I := READ_IMAGE( "mandy.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 256 Ny = 246
H := Histo( I)
3
1.276⋅ 10
Binarisation ( I , seuil ) :=
H ng
0 ng 255
seuil := 100
W := Binarisation ( I , seuil )
H := Histo( W)
3
1.276⋅ 10
H ng
0 ng 255
Image originale Image binarisée
I W
TP 1. 6
7. Rotation d'image Perfectionner l'algorithme de Rotation proposé (troncature calcul -> trous dans image résultat)
Lecture N&B :
I := READ_IMAGE( "coco.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
π
Rotate( I , angle_deg , x0 , y0) := angle_rad ← ( angle_deg) ⋅
180
for y ∈ 0 .. rows( I) − 1
for x ∈ 0 .. cols( I) − 1
J ←0 Fond noir
y, x
for y ∈ 0 .. rows( I) − 1
for x ∈ 0 .. cols( I) − 1
xr ← round [ ( x − x0) ⋅ cos( angle_rad) − ( y − y0) ⋅ sin( angle_rad) + x0]
yr ← round [ ( x − x0) ⋅ sin( angle_rad) + ( y − y0) ⋅ cos( angle_rad) + y0]
J ←I if xr ≥ 0 ∧ yr ≥ 0 ∧ xr ≤ cols( I) − 1 ∧ yr ≤ rows( I) − 1 Rotation
yr , xr y, x
J
J := Rotate I , 20 ,
cols( I) rows( I) 
, 
 2 2 
I J
TP 1. 7
Démonstration de la formule de rotation :
Rotation d’un angle θ d’un point de coordonnées (x , y) vers un point de coordonnées (xr , yr )
cos(a + b) = cos a ⋅ cos b − sin a ⋅ sin b
Rappel : 
sin(a + b ) = sin a ⋅ cos b + sin b ⋅ cos a
yr θ
β
d
y
d α
xr x
cos α = ( x / d )
On a : 
sin α = ( y / d )
cos β = (xr / d ) cos(α + θ ) = ( xr / d ) cos α ⋅ cosθ − sin α ⋅ sin θ = ( xr / d )

Soit β = α + θ :  → →
sin β = ( yr / d ) sin (α + θ ) = ( y r / d ) sin α ⋅ cosθ + sin θ ⋅ cos α = ( yr / d )
( x / d ) ⋅ cos θ − ( y / d ) ⋅ sin θ = ( x r / d )  xr = x ⋅ cos θ − y ⋅ sin θ

→  → 
( y / d ) ⋅ cos θ + sin θ ⋅ ( x / d ) = ( y r / d )  y r = y ⋅ cos θ + x ⋅ sin θ
 xr   cos θ − sin θ   x 
→   =  ⋅ 
 y r   sin θ cosθ   y 
__________
TP 1. 8
Traitement d'images 2. Filtrage
2. Filtrage
1. Filtrage - Renforcement du contraste
≡ 1 Dimension)
1.1. Rappels sur le filtrage linéaire 1D (≡
Soit un système linéaire stationnaire, continu ou discret.

continue δ (t ) h(t )
δ (n ) h (n )
Sa réponse à l'impulsion de Dirac est notée : .
discrète
h(t )
h(n )
est appelée Réponse Impulsionnelle (RI) et caractérise entièrement le filtre.
Temps Continu (TC) : Temps Discret (TD) :
x(t) h(t) y(t) = h(t) * x(t) x(n) y(n) = h(n) * x(n)

h(n)
(convolution)
∞ ∞
y (t ) = h(t ) * x(t ) = ∫ x(τ )h(t − τ )dτ
−∞
y ( n) = h ( n ) * x ( n) = ∑ x ( k ) h( n − k )
k = −∞
δ(t) δ(n)
1 1
Impulsion de Dirac ∞
t ∞ n
0
∫ −∞
δ (t )dt = 1 0 ∑ δ ( n) = 1
n = −∞
Démonstration :
δ(t) h(t) δ(n) h(n)

h(t) RI h(n)
δ(t- τ) h(t-τ) δ(n-k) h(n-k)

h(t) Sytème Stationnaire h(n)
x(τ).δ (t- τ) x( τ) .h(t-τ) x(k). δ (n-k) x( k) .h(n-k)

h(t) Système Linéaire h(n)
∞ ∞
x(τ )h(t − τ )dτ
∞ ∞
∫ x(τ )δ (t − τ )dτ ∫ ∑ x(k ).δ (n − k ) ∑ x(k ).h(n − k )
−∞ −∞
k = −∞ k = −∞
= x(t) h(t) = h(t) * x(t) = x(n) h(n) = h(n)* x(n)
Systeme Linéaire
x(t) h(t) y(t) = h(t) * x(t) x(n) h(n) y(n) = h(n)*x(n)

Filtre Linéaire
2. 1
x(t) h(t) y(t) = h(t) * x(t) x(n) h(n) y(n) = h(n)* x(n)
Temps:
TF ↓ (Transformée de Fourier) TZ ↓ (Transformée en z)
H(ν) Y(ν)= H(ν) X(ν)

X (ν) X (z) Y(z)= H(z) X(z)
Fréquence : H(z)
H(ν) : Fonction de Transfert (FT) du Filtre continu : H(z) : FT du Filtre discret :

H(ν) = TF( h(t) ) H(z) = TZ( h(n) )
- Passage Continu → Discret (1D)

Continu Discret Opération
f(x) f(n)
df ( x )
= ∇f ( x )
Gradient(x): Temps Continu (TC) :
dx Non Causal: Gradient(n) = ∇f (n ) = f (n + 1) − f (n) = f (n + 1) − f (n) Dérivation d'ordre 1
f ( x + ∆x ) − f ( x ) 1
= lim
∆x Causal: Gradient(n) = ∇f (n ) = f (n ) − f (n − 1) = f (n ) − f (n − 1) Temps Discret (TD) :
∆x → 0 1 Différence à 1 pas
n+ p TC : Intégration
∫
x0 + x
x0
f (u )d (u ) ∑ f (k )
k= p TD : Sommation
Laplacien(x): Causal: Laplacien(n)= ∆f ( n) = ∇ f (n ) − ∇ f (n − 1) = ∇ f (n ) − ∇ f (n − 1)
1 TC:Dérivation
d 2 f (x) ∆f (n) = f (n) − f (n − 1) − f (n − 1) + f (n − 2)
= ∇2 f ( x ) d'ordre 2
dx 2 ∆f ( n) = f ( n) − 2 f ( n − 1) + f ( n − 2)
= ∆ f (x ) TD:Différence
∆f ( n ) centré = f ( n + 1) − 2 f ( n) + f ( n − 1)
d'ordre 2
Exemple1 : Masque 1D de la RI de l’opérateur ∇1D non causal de relation d’entrée xn / sortie yn : yn = xn +1 − xn :

Masque :
1 -1 0
∞ +1
h−1 = 1
RI : hn = δ n +1 − δ n = hn * xn = ∑h x
k = −∞
k n−k = ∑h x
k = −1
k n−k ( hn = yn xn =δ n
) → h0 = −1
h1 = 0
Exemple2 : Masque 1D de la RI de l’opérateur ∆ 1D de relation d’entrée xn / sortie yn : y n = x n +1 − 2 x n + x n −1 :

∞ +1
yn = xn +1 − 2 xn + xn −1 = hn * xn = ∑h x
k = −∞
k n−k = ∑h x
k = −1
k n−k
h−1 = 1
→ RI : Par identification : hn est telle que : h0 = −2 → hn = δ n−1 − 2δ n + δ n +1
h1 = 1
Masque :
1 -2 1
2. 2
1.2. Renforcement du contraste
But : - accentuer les zones de transition (≡ hautes fréquences).

→ utilisation d'un filtre passe-haut (≡ dérivateur).
Effet bénéfique : - éliminer le flou.

Remarque : le flou peut aussi être éliminé en sous-échantillonnant l’image, réduisant la largeur des transitions et les rendant ainsi plus nettes.
Effet indésirable : - amplification du bruit.

(le bruit occupant des fréquences élevées, il se trouve amplifié par le filtre dérivateur).
→ tout opérateur de renforcement de contraste basé à partir d’un dérivateur va amplifier les bruits dans les zones à prori
homogènes de l'image.
Ramenons le caractère 2D d'une image, à 1D en considérant une ligne d'image :
Niveau de gris sur une ligne d'image
Contraste
x
Transition
Rappels:
f(x) F( ν ) : Spectre en Fréquence de f(x)
HF TF
BF
x ν
HF : le signal occupe des Hautes Fréquences (signal rapide) car : TF[δ(x)] = 1
BF : le signal occupe des Basses Fréquences (signal lent) car : TF[k] = k.δ(ν)
∞
f ( x) →
TF
F (ν ) = ∫ f ( x )e
−i 2πνx
dx
−∞
df ( x ) TF
g ( x) = → G (ν ) = i 2πνF (ν )
dx
x0 + x
F (ν )
j ( x) = ∫ f (u )du →
TF
J (ν ) = + kδ (ν ) (k : Cte à déterminer)
x0
i 2πν
G(ν) = 2πν F (ν) J (ν) = F (ν) / 2πν pour ν 0
ν ν
Le filtre dérivateur Le filtre intégrateur
amplifie les Hautes Fréquences amplifie les Basses Fréquences
2. 3
1.3. Opérateur Renforcement de Contraste (R) basé sur le Laplacien discrétisé : ∆
Principe 1D :
Contraste
signal (luminance) : f(x)
∇ f(x)
∆f(x) = ∇ 2f(x)
Contraste
Renforcé
R[f(x)]=f(x) - ∇ 2f(x)=f(x) - ∆f(x)
Déterminons tout d'abord l'équation aux différences caractérisant l'opérateur Laplacien ∆ = ∇2 :
1D (x) : (x est discret)
∆1D f(x) = ∆xf (x) = f(x) - 2f(x-1) + f(x-2) → ∆xf(x) = f(x+1) - 2f(x) + f(x-1) (→ non causal)
recentré (changement de variable : x → x + 1)
L’algorithme de traitement du pixel de coordonnées (x) et de luminance f, traduit par l’équation :

∆xf(x) = 1.f(x+1) - 2.f(x) + 1.f(x-1)
est habituellement représenté par le masque de convolution 1D d’application au pixel courant (x) symbolisé par * :
1 -2 * 1
En effet, ∆xf(x) résulte de la convolution entre une ligne d’image f(x) et la RI de l’opérateur Laplacien ∆x :
1 ∆ x (−1) = 1
∆xf(x) = f(x)* ∆x = ∆x *f(x) = 1.f(x-1)-2.f(x)+1.f(x+1) = ∑ f ( x + k ) ⋅ ∆ x ( k ) → ∆ (0) = −2 soit avec la représentation
 x
k = −1
∆ (1) = 1
 x
en masque : ∆x = 1 -2 * 1 (* représente le point central d’application du masque)
2D (x)(y) :
Plusieurs choix sont possibles pour ramener à 2D un filtre 1D :
• choix le plus courant : ∆2Df(x,y) = 1 [∆xf(x,y) + ∆yf(x,y)] (facteur 1 pour normalisation)

2 2
Ce choix revient à appliquer le filtre 1D d'abord sur chaque ligne de l'image d'origine,
puis ensuite sur chaque colonne de l'image d'origine, et de mixer les 2 effets.
2. 4
Autres choix possibles pour ∆2D f(x,y) :

• ∆xf(x,y) * ∆yf(x,y) (convolution) = 1 [∆xf(x,y) + ∆yg(x,y)] avec g(x,y) = ∆xf(x,y)
2
(facteur 1 pour normalisation)
2
Ce choix revient à appliquer le filtre 1D d'abord sur chaque ligne de l'image d'origine,
puis ensuite sur chaque colonne de l'image obtenue, c'est-à-dire l'image déjà filtrée en x.
Cette méthode présente un caractère récursif (l’effet du filtrage est plus important).
•
∆ x
f ( x, y ) + ∆ y f ( x, y )
• etc...
Opérateur Laplacien ∇2D :

∇ 2 D I ( x, y ) = ∇ 1Dx I ( x, y ) + ∇ 1D y I ( x, y ) = I ( x − 1, y ) − I ( x, y ) + I ( x, y − 1) − I ( x, y ) = I ( x − 1, y ) − 2 I ( x, y ) + I ( x, y −
Masque :
0 1 0
*
1 -2 0
0 0 0
Opérateur Laplacien ∆2D :
Avec le choix usuel : ∆2D f(x,y) = ∆x f(x,y) + ∆y f(x,y) (le facteur de normalisation 1 est inutile ici car l’opérateur est dérivateur :
2
Somme des poids de masque = 0), on obtient :
∆2D f(x,y) = f(x + 1,y) - 2f(x,y) + f(x - 1,y) + f(x,y + 1) - 2f(x,y) + f(x,y - 1)
←→ ←→
∆x ∆y
∆2D f(x,y) = [0].f(x - 1,y - 1) + [1] . f(x ,y - 1) + [0].f(x + 1,y - 1)
+ [1].f(x - 1,y) + [- 4].f(x ,y) + [1].f(x + 1,y)
+ [0].f(x - 1, y + 1) + [1] . f(x ,y + 1) + [0].f(x + 1, y + 1)
Soit le masque 2D (3x3) : h(x,y) (masque de l'opérateur Laplacien 2D) :
x
0 1 0 h(-1,-1) h(0,-1) h(1,-1)
Y 1 -4 1 ≡ h(-1,0) h(0,0) h(1,0)
0 1 0 h(-1,1) h(0,1) h(1,1)
On a bien une convolution 2D :
Image résultat g(x,y) = Image originale f(x,y) convoluée avec h(x,y) :
g(x,y) = ∆2Df(x,y) = f(x,y) * h(x,y)
1 1
g ( x, y ) = ∑ ∑ h(i,j ). f ( x + i,y + j )
i = −1 j= −1
Remarque : si on veut faire apparaître rigoureusement un produit de convolution :

1 1
g ( x, y ) = ∑ ∑ h(i, j ). f ( x − i, y − j )
i = −1 j = −1
il aurait fallu noter, mais c'est moins simple d'utilisation, le masque h(x,y) de la façon suivante :
h(1,1) h(0,1) h(-1,1)

h(1,0) h(0,0) h(-1,0)
h(1,-1) h(0,-1) h(-1,-1)
2. 5
Le masque (3x3) correspondant au filtre Laplacien ∆ est donc :
∆(x,y) 0 1 0
1 -4 * 1
0 1 0
(* symbolise le pixel central d'application du masque).
La somme des poids du masque d’un dérivateur est nulle.

Ex. : 1D : ∇ : 1 - 1 = 0 2D : ∆ : 1 + 1 + 1 + 1 - 4 = 0
Opérateur Renforcement de contraste à base de Laplacien R2D :
L'opérateur de renforcement de contraste à base de Laplacien peut être généralisé en paramétrant par un facteur (k) son
degré d'action. Il devient alors, et il est noté Rk :
g(x,y) = Rk (f(x,y)) = f(x,y) - k. ∇ 2f(x,y))
g(x,y) : point traité
f(x,y) : point initial
k : facteur de pondération du filtre
∇2 : opérateur Laplacien ( ∆ )
Rk : opérateur de Renforcement de contraste par Laplacien
Rk = 1 - k. ∇ 2 0 1 0
avec : ∇ = 2 1 -4 * 1
0 1 0
Rk est un opérateur linéaire (→ il est caractérisé par sa RI et possède une FT ) car le pixel traité par Rk est le résultat
d'une combinaison linéaire de pixels dans un voisinage donné (ici 3x3).
Masque correspondant à Rk: Masque correspondant à R1 (k = 1) :

0 -k 0 0 -1 0
Rk : -k 1+4k -k R1 : (k=1) -1 5 -1
0 -k 0 0 -1 0
R2D : (k=1) :
{[ ] [
R2 D I ( x, y ) = I ( x, y ) − ∇ 22 D I ( x, y ) = I ( x, y ) − ∇ 12Dx I ( x, y ) + ∇ 12D y I ( x, y ) ]}
R2 D I ( x, y ) = I ( x, y ) − {[I ( x + 1, y ) − 2 I ( x, y ) + I ( x − 1, y )] + [I ( x, y + 1) − 2 I ( x, y ) + I ( x, y − 1) ]}
[0]I ( x − 1, y − 1) [− 1]I ( x, y − 1) [0]I ( x + 1, y − 1)  0 −1 0
R2 D I ( x, y ) =  [− 1]I ( x − 1, y ) [5]I ( x, y) [− 1]I ( x + 1, y )  = − 1 5 − 1
[0]I ( x − 1, y + 1) [− 1]I ( x, y + 1) [0]I ( x + 1, y + 1)  0 − 1 0 
 0 −1 0 
R2D = − 1 5 − 1
 0 − 1 0 
2. 6
- Normalisation du Filtre :
Pour que l'image résultat d'un filtrage soit codée avec la même dynamique globale que l'image initiale, on procède à la
normalisation du filtre, c'est-à-dire que l'on divise tous les poids du masque par la somme des poids du masque : ∑
poids (si ∑poids ≠ 0, car dans le cas où ∑poids = 0 (opérateur dérivateur), la normalisation n’a pas lieu d’être (pas de
dépassement de dynamique possible)) :
0 -k 0
Rk : ∑poids)
(1/∑ -k 1+4k -k
0 -k 0
Pour l'opérateur Rk , la normalisation est inutile : ∑poids = 1.
- Dépassements locaux :
Il peut néanmoins y avoir des dépassements locaux même avec normalisation, et on veillera à borner le niveau de gris à
l'intérieur de la dynamique donnée.
- Application du masque de filtrage :

L'image est balayée par exemple horizontalement de haut en bas et de gauche à droite (si le filtre est causal ou bien non
causal mais non récursif. S’il est non causal et récursif en x, il doit être appliqué de droite à gauche sur l’image).
Le masque de convolution est appliqué sur chaque point de l'image (≡ point central du masque).
Le niveau de gris du pixel central est remplacé par la convolution du voisinage avec le masque.
Le niveau de gris résultat est stocké dans une nouvelle image et non l'image d'origine pour ne pas obtenir d'effet récursif
du filtre.
- Variantes :
On peut définir des variantes de R1 : Exemple RV : Pour obtenir un renforcement de contraste plus léger que R1 (poids
accru pour le pixel central) :
0 -1 0
RV : 1/5 -1 9 -1
0 -1 0
Plus le poids relatif du pixel central est important, moins l’effet du filtre sera important car le pixel central représente le
pixel initial).
Algorithme d'application du masque h de convolution (3x3) d'un Filtre Linéaire :
Début
Saisir les 9 poids du masque : h[i,j] pour i= -1,0,1 et j= -1,0,1
Pour y = 1 à NY - 2 Faire /* Effet de bord : on ne traite pas la 1ère ni la dernière ligne d'image */
Pour x = 1 à NX - 2 Faire /* on ne traite pas la 1ère ni la dernière colonne */
Somme = 0
Pour j = -1 à 1 Faire
Pour i = -1 à 1 Faire
Somme = Somme + h[i,j] * IM[x+i,y+j] /* * : produit simple */
Fp Fp
WM[x,y] = Somme
Fp
Fp
Fin
2. 7
- Remarques :
* Filtrage récursif : Si on range le niveau de gris du pixel traité dans l'image d'origine IM,
on obtient un filtre récursif :
Exemple : Gradient 1D : - non récursif : ∇f(n) ≡ g(n) = f(n) - f(n-1)

- récursif : ∇f(n) ≡ g(n) = f(n) - g(n-1)
* Généralisation : convolution 2D avec un masque de taille nxn (n: impair) au lieu de 3x3:
Plutôt que restreindre l'application du filtre à un voisinage 3x3 (2D), on peut augmenter la taille du masque de filtre pour
prendre plus en compte le voisinage du point traité.
Ceci accroît sensiblement le coût en temps calcul du filtre. On se restreint généralement à un voisinage 3x3, ou 5x5 tout au
plus.
n −1 n −1
2 2
g( x, y) = ∑ ∑ h (i , j ) f ( x + i , y + j )
n −1 n −1
i =− j =−
2 2
* Masque 1D : la notion de masque se définit bien évidemment également à 1D :
Exemple : Gradient 1D : ∇f(n) ≡ g(n) = f(n) - f(n-1)
Masque (3x1) : ∇1D -1 1 * 0

( * : point central d'application du masque )
* Traitement de l’effet de bord : de façon quasi générale, le fait de ne pas traiter la première et la dernière ligne de
l’image, ni la première et la dernière colonne, ne pose pas de problème : l’information utile est en général au centre de
l’image ! Sinon, des stratégies comme la recopie de la 1ère ligne en ligne 0, de la 1ère colonne en colonne 0 etc ... ou
encore l’adaptation du masque au cas particulier des bords peuvent être adoptées.
Remarques :
. La somme des poids du masque d’un filtre dérivateur est nulle
. On doit prendre la valeur absolue du gradient pour pouvoir son intensité (on affiche un niveau de gris > 0 !).
. Le signe du gradient renseigne quant à lui sur la direction du gradient.
1.4. Compléments sur le Filtrage 2D
- Passage 1D → 2D :
Pour mettre en oeuvre un filtre 2D noté F, à partir de sa version 1D, on a vu que plusieurs
choix sont possibles (on rappelle que la convolution (*) est commutative et associative) :
1. F2D = 1 [Fx + Fy] → WM = F2D*IM = 1 (Fx + Fy) * IM = 1 (Fx * IM) + 1 (Fy * IM) = 1 [WMx + WMy]
2 2 2 2 2
avec : WMx = Fx * IM et WMy = Fy * IM
IM IM IM
Fx
1 1
+ ≡ F
2 2 2D
F
y
WM WM WM
x y
2. 8
2. F2D = 1 [Fx * Fy] → WM = F2D * IM = (Fx * Fy) * IM = (Fx * IM) * Fy = (Fy * IM) * Fx
2
= Temp * Fy avec Temp = Fx * IM
Ce choix conduit à un effet plus important du filtre du fait de la récursivité : l'image déjà filtrée en x (et non l'image
d'origine) est à son tour filtrée en y. Cette technique 2D est peu utilisée (on préfère éventuellement appliquer plusieurs
fois la forme non récursive).
Si on s'intéresse par exemple à la valeur absolue GM du gradient, et du fait que la dérivée fournie par l'opérateur ∇ est
signée, on peut calculer GM de plusieurs façons :
• GM = |GMx| + |GMy|
• GM = GM 2x + GM 2y
• GM = Sup ( |GMx| , |GMy| )
...
Exemple : opérateur Laplacien ∆ :
1. ∆ = ∆x + ∆y ∆f = (∆x + ∆y)f
1D : ∇f (n) = f(n) - f(n-1) (causal)

∆f (n) = ∇2f(n) = f(n) - f(n-1) - [ f(n-1) - f(n-2) ] = f(n) - 2f(n-1) + f(n-2)
Recentrage : ∆f (n) = f(n+1) - 2f(n) + f(n-1) (→ non causal)
2D : ∆f(x,y) = (∆x + ∆y)f(x,y) = f(x+1,y) - 2f(x,y) + f(x-1,y) + f(x,y+1) -2f(x,y) + f(x,y-1)
0 1 0 
 
→ ∆ 2 D = ∆ x , y = ∆ x + ∆ y = 1 − 4 1 
0 1 0
image résultat : g(x,y) ; image d'origine : f(x,y) ; g(x,y) = ∆x,y * f(x,y)
Remarque : Attention à l'implémentation, le Laplacien (dérivée seconde) peut prendre des valeurs négatives :
→ on doit affecter au pixel central non pas : ∆* f mais : | ∆* f | car un niveau de gris < 0 ne peut être affiché.
2. ∆ = ∆x * ∆y
2D : ∆f = (∆x * ∆y) * f = (∆x * f) * ∆y = Temp * ∆y = g(x,y) avec Temp = ∆x * f

→ Temp(x,y) = f(x+1,y) - 2f(x,y) + f(x-1,y)
g(x,y) = Temp(x,y+1) - 2Temp(x,y) + Temp(x,y-1)

= f(x+1,y+1)-2f(x,y+1)+f(x-1,y+1)-2[f(x+1,y)-2f(x,y)+f(x-1,y)]+f(x+1,y-1)-2f(x,y-1)+f(x-1,y-1)
g(x,y) = [1].f(x - 1,y - 1) + [-2] . f(x ,y - 1) + [1].f(x + 1,y - 1)

+ [-2].f(x - 1,y) + [4] . f(x ,y) + [-2].f(x + 1,y)
+ [1].f(x - 1, y + 1) + [-2] . f(x ,y + 1) + [1].f(x + 1, y + 1)
 1 −2 1 
 
→ ∆ 2 D = ∆ x , y = ∆ x * ∆ y =  − 2 4 − 2
 1 − 2 1 
2. 9
L'ordre d'application des filtres est indifférent, la convolution étant commutative.
- Mise en cascade de 2 Filtres :
Le filtre H résultant de la mise en cascade de 2 filtres F et G 2D est obtenu de la façon suivante :

H2D = F2D * G2D → WM = H2D * IM = F2D * G2D * IM
Avec le choix non récursif de la version 1. : F2D = Fx + Fy et G2D = Gx + Gy on a :
WM = (Fx + Fy) * (Gx + Gy) * IM = Fx*Gx*IM + Fx*Gy*IM + Fy*Gx*IM + Fy*Gy*IM

←→ ←→
WMx WMy
On peut se restreindre au seul calcul de Fx*Gy*IM et Fy*Gx*IM (car chaque filtre intervient en x et en y) et
négliger l'effet de Fx*Gx et Fy*Gy sur l'image :
WM = WMx + WMy = Fx*Gy*IM + Fy*Gx*IM
avec : WMx = Fx*Gy*IM = (Fx*IM)*Gy = Temp*Gy avec : Temp = Fx*IM.
1.5. Opérateur de Chanda de renforcement de contraste (filtre non linéaire)
L'idée consiste à utiliser 8 domaines (D1 à D8) de 6 points dans le voisinage 5x5 du point traité, et à calculer pour
chaque domaine, un paramètre statistique d’ordre 1: la moyenne (ou la médiane) et un paramètre statistique d’ordre 2:
l'étendue (ou l'écart-type) des niveaux de gris :
(* : point central d’application du masque)
* * ... *
D1 D2 ... D8
D3, D5 et D7 sont obtenus par rotation de 90° par rapport au centre du voisinage 5x5 de D1.
D4, D6 et D8 sont obtenus par rotation de 90° par rapport au centre du voisinage 5x5 de D2.
Soit le Domaine Dk (1≤k≤8) de moyenne µk, d'étendue Ek, de médiane Mk et d'écart-type σk :
Paramètre statistique d’ordre 1:

1
- La moyenne µk est définie par : µk = ∑ gris = gris sur Dk
6 Dk
avec : gris ≡ niveau de gris.
- La médiane Mk du Domaine Dk est le niveau de gris situé au rang central (rang 3) de l'intervalle
ordonné des niveaux de gris des 6 points du Domaine Dk.
Paramètre statistique d’ordre 2:
- L'écart-type σk est défini par : σ k = gris sur

2
[
Dk − gris sur Dk ] 2
= 2
gris sur Dk − µ k
2
- L'étendue Ek est définie par : E k = (max− min) sur Dk avec :
max : niveau de gris le plus élevé du Domaine Dk.

min : niveau de gris le plus faible du Domaine Dk.
2. 10
L'opérateur effectue une somme pondérée des différences entre les moyennes des domaines et le niveau de gris du point
central. Tous les termes de pondération sont inférieurs ou égaux à 1, et élevés à la puissance n : (n : degré d'action du
filtre)
Soit : g(x,y) : point traité; f(x,y) : point initial; Gk = σk / Sup( σm ) [m=1 à 8]
pour k= 1 à 8
8
∑ (G ) .(µ
k
n
k − f ( x, y ))
g ( x, y ) = f ( x , y ) − k =1
8
∑ (G )
k =1
k
n
Algorithme (optimisé) de l'application de l'opérateur de Chanda :
Début
Choix de n (n = 1 recommandé)
Pour chaque point de l'image Faire :

SDG = 0; SG = 0
Pour k = 1 à 8 Faire
S = ( Σ gris sur Dk ) / 6 /* gris : niveau de gris */
S2 = ( Σ gris 2 sur Dk ) / 6
D = S - f(x,y) /* f(x,y) : point courant traité */

G = | S2 - S 2 | n/2
SDG = SDG + D*G
SG = SG + G
Fp
g(x,y) = f(x,y) - SDG/SG
Fp
Fin
L'opérateur de Chanda a des performances supérieures au renforcement de contraste par Laplacien

mais au prix d'une complexité (temps calcul et réalisation sur circuit câblé) très sensiblement accrus.
2. Lissage linéaire
L'opération de lissage est destinée à rendre plus homogènes les différentes parties (régions) de l'image, et préparer ainsi
la détection des contours en éliminant les fortes variations d'intensité lumineuse ponctuelles non significatives.
Un filtre de type passe-bas (≡ intégrateur) sera donc utilisé, et il aura donc généralement pour effet secondaire de
diminuer le contraste (≡ rendre l'image plus floue).
Selon la nature du bruit présent dans l'image, différents types de lissage sont envisagés.
2. 11
2.1. Lissage par la Moyenne

Le lissage par la moyenne consiste à effectuer une somme.
Le filtre moyenneur est donc bien un intégrateur (≡ sommateur, ≡ passe-bas).
1 1 1 h−1, −1 h0, −1 h1, −1 

1  
Moyenne 3x3 : Masque de convolution :
 1 1 1 =  h−1,0 h0, 0 h1, 0 
9
1 1 1  h−1,1 h0,1 h1,1 
Plus la taille du masque est élevée, plus le filtre est actif mais plus le coût en temps calcul est élevé.
Chaque point IM[x,y] de l'image initiale devient dans l'image résultat :
1 1
WM x , y = ∑ ∑ h i , j ⋅ IM x + i , y + j
i =−1 j =−1
Masque 1/9 1/9 1/9

de la 1/9 1/9 * 1/9 (* : point central d'application du masque)
Moyenne : 1/9 1/9 1/9
RI 1D du filtre moyenneur 1D : 1/3 * 1/3 1/3
1/3
2.2. Lissage Gaussien

Le filtre gaussien est connu comme un bon générateur de flou.
Rappel : courbe de Gauss 1D :
x2
− 2
gσ (x ) =
1
⋅ e 2σ σ : écart-type : largeur à mi-hauteur.
σ 2π
Propriétés :
∞
∫ gσ (x )dx = 1
−∞
σ
∫ σ g σ (x )dx = 0.95
2
−2
σ
∫ σ g σ (x )dx = 0.999
3
−3
−
(x 2
+ y2 )
g σ ( x, y ) =
1
Courbe de Gauss 2D : ⋅e 2σ 2
σ 2π
Cas 1D : gσ(x) : Réponse impulsionnelle du filtre gaussien (RI)
gσ(x) : RI Infinie (RII) car son support est non borné.
Ceci conduit à un filtre récursif, sans quoi il faut tronquer le filtre si on le laisse sous forme non récursive.
(un filtre RIF (RI Finie) conduit à un filtre non récursif).
2. 12
Rappel : Filtres RII (récursifs) et RIF (non récursifs) :
Exemples : (a) filtre RIF 1D Moyenneur non récursif causal : y ( n) =

1
2
(
x( n ) + x( n − 1) )
RI : h(n) =
1
2
(
δ ( n − 1) + δ ( n ) ) obtenue pour x(n) = δ(n).
h(n) - filtre causal car y(n) ne s'exprime pas en fonction du futur

(ou encore : h(n) = 0 pour n<0)
1/2
- filtre non récursif car y(n) s'exprime seulement en fonction
n de l'entrée x, et non de y à un autre instant.
0 1
RIF - RIF <------> non récursif
b) filtre RII 1D Moyenneur récursif causal : y ( n) =

1
2
(
x( n ) + y( n − 1) ) (1)
Prenons la Transformée en z (TZ) de la relation (1) :
1 X (z )
Y ( z) =
1
2
[ ]
X ( z ) + z −1Y ( z ) →Y ( z ) = .
2 1 − 1 z −1
2
car si : f (n ) → F ( z ) alors : f (n − k ) → z .F ( z )
TZ TZ −k
On a également en z : Y(z) = H(z).X(z) avec H(z) : Fonction de Transfert (FT) du système

numérique.
1 1 1 z
→ H ( z) = ⋅ = ⋅
2 1 − 1 z −1 2 z − 1
2 2
La FT H(z) étant la TZ de la RI h(n), on a donc :
n n +1
−1 1 1 1
h(n) = TZ ( H ( z )) = ⋅   =   pour n ≥ 0 (h(n) causale) (cf tables )
2 2 2
h(n)
1/2
- RII <----> récursif
n
0 1 2 3 4 5
RII
2. 13
Rappel : Troncature d'un filtre :
On peut néanmoins tronquer un filtre récursif (≡ RII) par un filtre non récursif (≡ RIF) :
Exemple :
Filtre : y (n ) =
1
2
(x( n ) + y( n − 1) ) → y (n − 1) =
1
2
(
x( n − 1) + y( n − 2 ) )
(
y (n − 2 ) = x( n − 2 ) + y( n − 3)
1
2
)
...
∞
1 
y(n ) =  x(n ) + x(n − 1) + x(n − 2 ) + ...  = ∑ x(n − k )
1 1 1
→
2 2 4  k =0 2 k +1
∞
δ (n − k )
1
RI : h ( n) = ∑ de support infini : RII
k =0 2 k +1
N
δ (n − k ) :
1
Troncature : → h ( n) = ∑ Somme sur N termes : support N+1 → RIF
k =0 2 k +1
( ∞ remplacé par N (majorant) )
→ Masque de taille infinie remplacé par un masque de taille N : erreur de troncature.

Celle-ci n'apparait pas pour un filtre récursif car on utilise alors la Transformée en z.
Application pour le filtre Gaussien :

Troncature du filtre gaussien (cas 1D) : on peut se limiter à un masque de taille n :
n = 2σ + 1 (RI tronquée sur le support −σ 0 σ )

n (impair) : n = 4σ + 1 (RI tronquée sur le support − 2σ → +2σ )
n = 6σ + 1 (RI tronquée sur le support − 3σ → +3σ )
La RI non tronquée gσ(x) étant quasiment nulle hors de l'intervalle de x : [-2σ , 2σ], la troncature dès n = 4σ + 1
n'introduit pas d'erreur sensible pour une implémentation non récursive du filtre.
Calcul du masque h1D pour une troncature n = 2σ + 1 :
Exemple : σ = 1 : → masque de taille n = 3 :
b a* b
RI du filtre Gaussien :
x2  x2 
avec : 
− − 
σ 2 σ 2
a = gσ (x = 0) =
1 1
b = gσ ( x = σ ) =
1 1
⋅e 2
 = ≅ 0.4 ⋅e 2
 = ⋅ e − 0.5 ≅ 0.24
σ 2π  2π σ 2π  2π
 
 x=0  x =σ
2. 14
 1
 a = g σ ( x = 0) = σ =α
 2π
Avec σ quelconque :  σ2
− 2
b = g ( x = σ ) = 1
e 2σ = β
 σ
σ 2π
→ Masque normalisé : 1 / (α + 2 β ) β α β
→ Masque de la RI 1D non récursive du filtre gaussien tronqué sur [-σ 0 +σ] avec σ = 1 normalisé:
1/ 0.88 0.24 0.4 0.24 soit : 0.274 0.452 0.274
Filtre gaussien 1D récursif (≡ non tronqué)
Si l’on ne veut pas perdre en précision en ce qui concerne l’implémentation du filtre gaussien, on utilise alors la TZ de la
n2
1 − ∆ Y ( z)
RI g n (1D) du filtre gaussien : g n = e 2σ 2
→
TZ
G( z ) = L =
2π X ( z)
conduisant à une relation d’Entrée/Sortie récursive du fitre gaussien d’entrée x n et de sortie y n : yn = L
Filtre gaussien et filtre moyenneur
La comparaison du filtre gaussien 1D tronqué avec le filtre moyenneur 1D :
1/3 * 1/3 1/3
dont la RI est :
1/3
montre que le poids relatif accordé au pixel central est plus important pour le fitre gaussien. Ce dernier engendre donc
un flou moins important que le filtre moyenneur.
Algorithme de l'implémentation non récursive du filtre Gaussien 2D :

( masque h de taille n x n obtenu d'après g (x,y) )
σ
Début
Pour tout point (x,y) de l'image IM (sauf aux bords) Faire
WM[x,y] = 0
Pour j = -(n-1)/2 (n-1)/2
Pour i = -(n-1)/2 (n-1)/2
WM[x,y] = h[i,j].IM(x+i,y+j] + WM[x,y]
Fp
Fp
Fp
Fin
2. 15
Remarque : le masque 2D h peut être obtenu par l'opérateur gσ(x) + gσ(y) (opérateur 1D en x + opérateur 1D en y sur
l'image initiale) ou encore directement d'après la RI 2D gσ(x,y) :
c B c
b A b
c B c
avec, en prenant σ =1 :
(x2 + y2 ) 
− 
a = gσ ( x = 0, y = 0 ) =
1
⋅e 2σ 2  = 1
≅ 0 .4
σ 2π  2π
 x = 0
y =0
( x2 + y 2 ) 
− 
b = gσ ( x = σ , y = 0 ) =
1
⋅e 2σ 2  =
1
⋅ e − 0.5 ≅ 0.24
σ 2π  2π
 x =σ
y =0
(x2 + y2 ) 
− 
c = gσ ( x = σ , y = σ ) =
1
⋅e 2σ 2  =
1
⋅ e−1 ≅ 0.15
σ 2π  2π
 x =σ
y =σ
pour une troncature sur [-σ 0 +σ]2D avec σ = 1.
Soit après normalisation :
0.075 0.124 0.075

0.124 0.204 0.124
0.075 0.124 0.075
Nombre d'opérations par point avec le masque 2D de taille nxn :
n 2 multiplications ( x )
(n 2
)
− 1 additions ( + )
Séparabilité du filtre :
Par exemple, un filtre 2D de RI hxy tel que hxy = hx * hy est séparable. On a dans ce cas : TF2D[hxy] = TF1D[hx].TF1D[hy]
Le filtre gaussien est séparable :
la convolution 2D avec le filtre gaussien nxn peut être séparée en 2 convolutions 1D avec :
- filtre 1 x n vertical (↓)
- filtre n x 1 horizontal (→)
En effet , on a : WM = IM * h2D (h2D ≡ hxy )
2. 16
(
− wx 2 + w y 2 )
TF2D [WM ] = TF2D [ IM ] . TF2D [h2 D ] = TF2D [IM ] ⋅ e 2σ 2
car TF (Gaussienne) = Gaussienne
− wx 2 − wy 2
TF2D [WM ] = TF2D [IM ] ⋅ e 2σ ⋅ e 2σ = TF2D [IM ] .TF1D [hx ].TF1D [h y ]

2 2
→
→ WM = IM * hx* hy
Par exemple, on peut écrire : WM = hx * Temp avec Temp = IM * hy.
On parle plus généralement de séparabilité d’un filtre lorsque le traitement 2D est équivalent à 2 traitements 1D du
filtre. Ainsi, un filtre tel que hxy = 1 [hx + hy] est également séparable.
2
Nombre d'opérations par point avec les 2 masques 1D :
Le nombre d'opérations par point est largement amoindri en utilisant la séparabilité du filtre :
n multiplications et (n-1) additions pour chaque filtre 1D :
2n multiplications ( x )
soit au total :
2( n − 1) additions ( +)
Conclusion sur le lissage linéaire :

Même principe pour implémenter tout filtre linéaire passe-bas de lissage dont on a la RI : ex. générateur d’écho
(d’image) : y n = x n + α y n −1
La donnée de la RI conduit à la détermination du masque de convolution selon le même principe que l’exemple du filtre Gaussien.
3. Lissage non linéaire

3.1. Lissage Médian
Il appartient plus généralement à la famille des filtres d'ordre. Leur nature non linéaire a pour but d'éviter de lisser des
transitions correspondant à des fronts raides que représentent les bords des objets par exemple, pour ne pas gêner la
détection de contours..
Un filtre d'ordre appliqué sur une fenêtre donnée de l'image, contenant la séquence {x(i)} de N pixels (N est impair : N
= 2p + 1), consiste à ordonner tout d'abord les valeurs {x(i)} de niveau de gris, de telle sorte à obtenir la séquence
ordonnée {xi} obéissant à la relation : x1 ≤ x2 ≤... ≤ xN
Après cette opération non linéaire de tri, on effectue une combinaison linéaire de la séquence ordonnée avec un masque
de convolution {Ci} de coefficients constants de pondération, pour l'affecter au point central y(p + 1) de la fenêtre :
N
y( p + 1) = ∑ Ci . xi
i =1
Le filtre médian de lissage (ou médian standard) est obtenu à partir de cette famille, en choisissant tous les coefficients
Ci nuls sauf Cp+1 qui est égal à 1.
On peut en rencontrer une variante, le filtre médian récursif de lissage, qui inclut dans la séquence d'entrée {x(i)}
courante, le résultat du filtrage dans la fenêtre précédente.
Du fait de leur non linéarité, les filtres d'ordre ne peuvent être caractérisés par leur RI et ne possèdent pas de FT, la FT
étant obtenue par une transformation linéaire (Laplace, Fourier, z).
2. 17
Application : Réjection du bruit impulsionnel ≠ moyenneur : ex:
Image de 3 2 4 Image 3 2 4
Départ : 1 255 * 3 Tri : 1 2 2 3 3 4 4 5 255 → Résultat: 1 3 * 3
4 2 5 4 2 5
Application audio: Réjection du bruit impulsionnel (craquements (disques vinyle) ...)
Algorithme rapide du lissage Médian :
L'algorithme de recherche, dans un ensemble de N éléments (N = 9 pour une fenêtre 3x3) de la médiane de cet ensemble
(n-ième élément dans la séquence ordonnée de N éléments), peut se faire de la façon suivante (partitionnement) :
- séparer l'ensemble des N éléments en N/k ensembles de k éléments (k = 3 par exemple).
- trouver les médianes des N/k ensembles et la médiane de ces médianes, soit x.
- séparer l'ensemble initial en deux sous-ensembles : celui des j éléments inférieurs à x et celui des (N - j) éléments qui
lui sont supérieurs, les éléments égaux à x étant mis alternativement d'un côté ou de l'autre. Si j est supérieur à n,
l'élément médian est représenté par le n-ième élément du premier sous-ensemble, et par le (n- j) -ième élément du
second dans le cas contraire.
Cette recherche rapide de la médiane demande un nombre d'opérations de l'ordre de N. On peut utiliser aussi des
méthodes générales de tri rapide en NlogN car ici N est faible.
3.2. Lissage de Nagao (variante)

(même famille que l’opérateur de Chanda, mais alors que l’opérateur de Chanda procède à un filtrage passe-haut, le filtre de Nagao effectue un
lissage passe-bas)
Opérateur non linéaire.
Principe
Une fenêtre 5x5 est déplacée sur l'image. Cette fenêtre est elle-même décomposée en 8 domaines (D0 à D7).
L'intensité du point central de la fenêtre 5x5 est remplacée (dans l'image résultat) par la moyenne (ou la médiane) du
domaine ayant l'étendue (ou la variance) la plus faible.
Cette fenêtre est déplacée sur l'image pour traiter chaque point.
D0 D1 D2 D3 D4 D5 D6 D7
point central d'application des masques des domaines
.
Résultats :
- excellentes performances (pas de flou généré).
- affinage des zones de transition.
- les plages homogènes de variance faible sont favorisées.
__________
2. 18
Traitement d'Images TP 2. Filtrage
TP 2. Filtrage
1. Convolution avec un masque 3x3. Application : Renforcement de contraste

Lecture N&B :
Nx = 147 Ny = 195
Fonction Convol3x3(I,Mask3x3)
Convol3x3( I , Mask3x3) :=
Renforcement de Contraste (k = 1)
 0 −1 0 
M :=  −1 5 −1  J := Convol3x3( I , M ) K := Convol3x3( J , M )
 
 0 −1 0 
Image originale Image à contraste renforcé Image à contraste renforcé 2 fois
J K
TP 2. 1
2. Dérivation d'une image

Lecture N&B :
I := READ_IMAGE( "cub.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 75 Ny = 120
Fonction Derivation(I,Mask3x3)
Derivation ( I , Mask3x3) :=
M := D := Derivation ( I , M )
Image originale Image dérivée
TP 2. 2
3. Renforcement de contraste : Opérateur de Chanda

Lecture N&B :
Nx = 147 Ny = 195
Fonction Chanda(I)
Chanda( I) :=
C := Chanda( I)
Image originale Image à contraste renforcé
TP 2. 3
4. Lissage
Lecture N&B :
Nx = 75 Ny = 120
Lissage par la moyenne :
 
M :=   Image originale Image lissée par la moyenne
J := Convol3x3( I , M )
 
 
Lissage médian :
Image originale Image lissée par le médian
J := Median( I)
Lissage gaussien :
 
M :=   Image originale Image lissée par la gaussienne
J := Convol3x3( I , M )
 
 
TP 2. 4
Lissage de Nagao :
Image originale Image lissée par Nagao
... J := Nagao( I)
TP 2. 5
TP 2 ANNEXE. Filtrage
1. Restauration (filtrage inverse)
Lecture N&B :
I := READ_IMAGE( "bato2.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 128 Ny = 128
Dégradation 1D :
Degrad1DColonne( I , f ) := g ←f Degrad1D( I) := for x ∈ 0 .. cols( I) − 1
0 0
〈x〉
g ←f −f f ←I
1 1 0
〈x〉
for n ∈ 2 .. rows( I) − 1 J ← Degrad1DColonne( I , f )
g ←f −f +f J
n n n− 1 n− 2
g
D := Degrad1D( I)
Restauration 1D :
Restau1DColonne ( I , f ) := g ←f Restau1D( I) := for x ∈ 0 .. cols( I) − 1

0 0
〈x〉
g ←f +g f ←I
1 1 0
〈x〉
for n ∈ 2 .. rows( I) − 1 J ← Restau1DColonne ( I , f )
g ← J
n
g
R := Restau1D( D)
Image originale Image dégradée Image restaurée
I D
TP 2. 6
2. FFT
FFT d'une image
I := READ_IMAGE( "bato2.bmp" )
FFT de l'image en effectuant la FFT de chaque colonne de l'image
FFT2D_Colonne( I) := J := FFT2D_Colonne( I)
Image originale Image module FFT
I J
Conclusion :
TP 2. 7
3. Transformée en ondelettes d'une image

I := READ_IMAGE( "bato2.bmp" )
Transformée en ondelettes (Daubechies) de l'image en l'effectuant sur chaque colonne de l'image
WAVE2D_Colonne( I) := J := WAVE2D_Colonne( I)
I J
Conclusion :
Transformée en ondelettes (Daubechies) de l'image en l'effectuant sur chaque ligne de l'image

Ligne( M , y) := for x ∈ 0 .. cols( M ) − 1 WAVE2D_Ligne( I) :=
v ←M
x y, x
v
J := WAVE2D_Ligne( I)
I J
TP 2. 8
4. DCT (Transformée de Fourier en Cosinus Discrète)
TP 2. 9
Fonctions Bibliothèques :
Histo( I) ≡ for ng ∈ 0 .. 255 RecadrageDyn( I) ≡ H ← Histo( I)

H ←0 for i ∈ 0 .. 255
ng
maxi ← i if H ≠ 0
for y ∈ 0 .. rows( I) − 1 i
for x ∈ 0 .. cols( I) − 1 for i ∈ 255 , 254 .. 0
ng ← I mini ← i if H ≠ 0
y, x i
H ←H +1 255
ng ng ∆←
maxi − mini
H
for y ∈ 0 .. rows( I) − 1
for x ∈ 0 .. cols( I) − 1
( y , x )
J ← round  I − mini ⋅ ∆
y, x 
J
__________
TP 2. 10
Traitement d'images 3. Segmentation des images
3. Segmentation des images

Principe : Comme pour la parole (segmentation d’une phrase en mots) pour la reconnaissance.
But : - démarrer l'interprétation de l'image
- réduire la quantité d'informations dans l'image, sans nuire de façon sensible à la compréhension
- structurer les informations de l’image.
2 approches : - segmentation en régions homogènes (≡ à partir de la texture) (Clustering)

- segmentation par extraction de contours (approche duale).
1. Segmentation en régions homogènes

Contrairement à l'extraction de contours qui s'intéresse aux bords d'une région, la segmentation en régions homogènes
vise à segmenter l'image en se basant sur les propriétés intrinsèques de la région.
Le choix de ces propriétés détermine ce que l'on appelle le critère de segmentation.
Il est en effet nécessaire de définir ce que l'on entend par "homogénéité" d'une région de l'image. Le critère qui définit
l'homogénéité est donc un point déterminant des performances de la segmentation. Les principaux critères utilisés sont le
niveau de gris (ou la couleur pour les images couleur), la texture et le mouvement.
Dans le cas d'une image aérienne, par exemple, une segmentation par la couleur permet d'isoler la végétation (champs
verts ou jaunes, labours bruns, forêts vertes), les routes (gris), et les toits (rouges).
Un exemple banal de segmentation du mouvement consiste à faire la différence entre deux images prises à deux instants
différents. Dans ce cas, les parties restées fixes donnent un résultat nul, les parties animées donnent un résultat positif ou
négatif correspondant au déplacement. Ces considérations nous montrent que la soustraction d'images n'est autre qu'une
approximation de la dérivée temporelle d'une image.
En effet, si T est le temps écoulé entre la prise de vue de deux images consécutives I(t) et I(t+T), et si T est petit, on
obtient directement une approximation de la dérivée en faisant :
∆I I (t + T ) − I (t )
=
∆t T
Nous voyons donc qu'il est possible de connaître ainsi la vitesse de déplacement d'objets sur l'image.
Il est en particulier possible, grâce à la soustraction, de déterminer l'apparition de nouveaux objets dans la scène (signe
positif) et la disparition d'objets de l'image précédente (signe négatif) :
Soustaction (valeur absolue) entre 2 images binaires :
Image_1 Image_2 Soustaction (valeur absolue)

| Image_1 - Image_2 |
3. 1
La texture est un élément très important en segmentation.
C'est elle qui nous permet de discerner un mur comme étant crépi et non lisse, qui nous permet de faire la différence
entre du gazon et une surface peinte en vert.
La texture caractérise les motifs répétitifs qui apparaissent sur une surface donnée (mur de briques, trame d'une étoffe...)
ou bien caractérise une répétition aléatoire d'une primitive
presque constante (sable, gazon...).
On définit la taille de la fenêtre qui contient le motif de base de la texture comme étant la résolution de celle-ci. Ce
motif de base est appelé primitive de texture ou texel et peut être considéré comme l'application d'une fonction de
modulation sur une fenêtre de taille nxm (nxm est la résolution de la texture).
La fonction de modulation peut être soit déterministe (dans ce cas le motif est identiquement représenté chaque fois
qu'on l'applique), soit aléatoire (le motif est alors caractérisé par des propriétés statistiques telles que moyennes,
variance, énergie, etc...).
L'ensemble de ces paramètres permet de caractériser la texture et forme ce que l'on appelle la signature de texture.
Il existe principalement trois approches de la segmentation en régions (clustering). Celles-ci sont indépendantes du
critère choisi et peuvent se décomposer comme suit :
1- Méthodes par séparation.

2- Méthode par fusion.
3- Méthode par séparation/fusion.
1- Méthodes globales ou par séparation (Split) - Quad Trees :
Le principe de ces méthodes consiste à tester la validité du critère de manière globale sur une large zone de l'image.
Si le critère est validé, l'algorithme s'arrête.
Sinon, on décompose la zone considérée en zones plus petites et on applique la méthode jusqu'à obtention d'une zone
qui valide le critère.
Ceci se traduit en pratique par une division de l'image originale en quatre, puis à nouveau une division de chacune de
ces zones en quatre, tant que le critère n'est pas vérifié :
Algorithme Récursif de la Segmentation en Régions par Séparation :

SEPARATION (Zone)
Début
Si critère(Zone) est VRAI alors Arrêt
Sinon
Diviser la Zone en 4 : soit Z1, Z2, Z3 et Z4
Pour chaque Zone Zi (i = 1 à 4) Faire
SEPARATION (Zi) ;
Fp Initialisation :
Fsi
Fin Zone = image entière
Cet algorithme produit un arbre appelé Quad Tree qui donne une structure hiérarchisée des régions qui correspondent au
critère.
Exemple de critère d’homogénéité : même niveau de gris du voisin à 10% près.
3. 2
Une région qui répond au critère forme un noeud terminal ou feuille de l'arbre, sinon elle forme un noeud d'où partent
quatre branches correspondant aux quatre zones sur lesquelles on rapplique l'algorithme.
Dans l'exemple suivant, le critère est celui de même couleur.
Si tous les pixels d'une zone sont blancs, alors le noeud est dit blanc et il est terminal.
De même pour un noeud noir.
Sinon le noeud est dit gris et on réapplique l'algorithme :
Segmentation en Régions par Séparation :
5 6 9 10 5 6 9 10
1 2 17 18
7 8 11 12 7 8 11 19 20
21 22 25 26
13 14 23 24 27 28
3 4 4 4
15 16 15 16
Image Originale 1er niveau 2ème niveau 3ème niveau

de séparation (final)
1 2 3 4
12 13 14
5 6 7 8 9 10 11 15 16
17 18 19 20 21 22 23 24 25 26 27 28
Quad-Tree correspondant
Remarque: Le nombre de régions déterminé ici par cette méthode est de 22 alors qu'il est clair que l'image initiale
n'en comporte que 2.
3. 3
2- Méthodes locales ou par fusion (Merge) -Méthodes dites "à croissance de régions"- :
L'idée des méthodes par fusion consiste à explorer l'image à partir de petites régions et à faire croître celles-ci. Ces
méthodes suivent donc le principe inverse de la séparation . La règle de fusion de deux régions est celle-ci :
- les deux régions répondent de manière similaires au critère (par exemple les deux régions ont des niveaux de gris
similaires).
- elles sont adjacentes.
Remarques sur la connexité :
Nous avons vu que la segmentation vise à séparer l'image en régions connexes ayant mêmes propriétés. Or la définition
de la connexité dans le cas d'une image numérique échantillonnée suivant un maillage carré n'est pas unique.
On peut en effet définir ce que l'on appelle la 4-connexité ou bien la 8-connexité.
La 4-connexité définit comme adjacents (≡ connexes), les pixels d'un point I[x,y] d'une image comme les 4 pixels
voisins suivant les directions x et y.
La 8-connexité définit comme adjacents non seulement les voisins suivant x et y, mais aussi ceux suivant les
diagonales. Elle donne lieu à un code appelé code de Freeman :
3 2 1
4 0
5 6 7
4-connexité 8-connexité et codage de Freeman associé
Ces définitions sont déterminantes dans la définition de la règle d'adjacence pour la fusion de deux régions :
Région 1 Région 2
Région 3 Région 5
Région 4
Région 6 Région 1 Région 2
Fusion en 4-Connexité Fusion en 8-Connexité de la même image
3. 4
Méthode locale récursive :
Cette méthode consiste à faire croître une région en utilisant les techniques de recherche dans un arbre.
La méthode de parcours de l'image n'est pas ici déterminée à l'avance, et l'algorithme se promène dans l'image afin de
faire croître au maximum une région avant de s'intéresser à la suivante :
Algorithme de Segmentation en Régions par Fusion :
Début Procédure CROISSANCE (pixel(x,y))

Pour chaque pixel (x,y) de l'image I Faire
Début
Si I[x,y] < > 0 alors
On met I[x,y] à 0 afin de ne pas réexaminer ce point (marquage)
Sauvegarder le point initial I[x,y]
(Condition d'arrêt de la procédure récursive)
CROISSANCE (pixel(x,y))
Incrémenter NuméroRégion Pour tout pixel adjacent à I[x,y] Faire
Fsi Si (I[x,y] < > 0) ET (Critère(pixel) vérifié) alors
Fp CROISSANCE (pixel(x,y));
Fsi
Fin
Fp
Fin
Cette méthode présente l'avantage d'être rapide et simple à réaliser.
3- Méthodes par séparation-fusion (Split and Merge) : Clustering
Les deux méthodes que nous venons de décrire présentent chacune des caractéristiques complémentaires.
Les méthodes par division fournissent une structure hiérarchisée permettant d'établir des relations de proximité entre les
régions mais fractionnent une même région en sous-ensembles distincts.
Les méthodes par fusion permettent d'obtenir le nombre minimal de régions connexes mais fournissent celles-ci sous une
structure horizontale ne donnant pas de relations de proximité entre les régions. Or ces relations sont d'une grande utilité
dans le cas d'une modélisation structurale de la scène.
C'est pourquoi a été définie une méthode combinant les deux méthodes appelée division-fusion.
On réalise tout d'abord une division en construisant le Quad-Tree dans le sens racine vers feuilles, puis on parcourt
l'arbre dans le sens feuilles vers racine en fusionnant les régions ayant même critère.
On obtient ainsi une description structurale de l'image avec des régions connexes de taille maximale.
1 2 3 4
12 13 14
5 6 7 8 9 10 11 15 16
17 18 19 20 21 22 23 24 25 26 27 28 1 2
Image Originale Quad-Tree obtenu par Séparation Quad-Tree par Séparation-Fusion

(22 régions dénombrées) (2 régions dénombrées)
Le Quad-Tree obtenu par application d'une méthode par division-fusion permet de ne dénombrer que 2 régions, ce qui
est bien le cas de l'image.
3. 5
2. Extraction de contours
Approche générale de l'extraction de contours :
1) Lissage préalable de l'image : (Moyenne, Médian, Nagao, ...)
But : → Réduire les bruits et affiner les zones de transition (filtrage passe-bas)
Ne retenir que les transitions significatives.
2) Dérivation :
But : → Détection proprement dite des transitions dans l'image (filtrage passe-haut).
Le bruit occupant des hautes fréquences, la dérivation va amplifier les bruits.
(Le laplacien est encore plus sensible au bruit).
2.a) Dérivation du 1er ordre (∇) ou 2.b) Dérivation du 2nd ordre (∆)
(Gradient) (Laplacien)
3) Suppression des discontinuités et amincissement des "contours" (étape optionnelle) :
3.a) Elimination des non maxima locaux ou 3.b) Elimination des non "zéros"
du module du gradient. locaux du module du laplacien.
4) Seuillage :
But : → ne retenir comme contours que les points de l'image possédant un fort gradient (en module), ou un
laplacien proche de 0 (en module).
4.a) Seuillage de l'image "norme du gradient" ou 4.b) Passage par zéro du laplacien (zero cross)
Sélection des maximas de la norme du gradient Sélection des passages par zéro de la norme
→ Contours extraits. du laplacien (à une tolérance près).
→ Contours extraits.
Dérivation du 1er et du 2nd ordre en présence d'un contour :

Niveau de gris sur une ligne d'image (2 contours)
x
Amplitude du gradient
Amplitude du laplacien
La dérivation étant un opérateur linéaire, on peut le caractériser par sa RI et donc déterminer son masque de convolution.
3. 6
Principaux masques de dérivation utilisés :
Roberts (1965) : ce masque découle directement de la dérivée discrète 1D :
- Gradient en x : G x [x, y ] = IM [x + 1, y ] − IM [x, y ] → Masque H x = [− 1 1] (1D)

0 0
Hx= -1 * 1 (* pixel central) : Masque Hx (2D)
− 1
- Gradient en y : G y [x, y ] = IM [x, y + 1] − IM [x, y ] → Masque Hy =   (1D)
1
-1 * 0
Hy= 1 0 (* pixel central) : Masque Hy (2D)
IM2D ∗ Hx2D → Gx2D ; IM2D ∗ Hy2D → Gy2D Les 2 masques 2D sont appliqués.
- Image de la norme du gradient : (pixel (x,y) considéré) : G[x, y ] = G x2 [x, y ] + G y2 [x, y ]

G y [x , y ]
D[x, y ] = Arctg
G x [x , y ]
- Image de la direction du gradient : (pixel (x,y)) considéré) :
Prewitt : 2 masques 2D sont appliqués (Hx pour donner Gx et Hy pour donner Gy) :
-1 0 1 -1 -1 -1
Hx = -1 0* 1 Hy = 0 0* 0
-1 0 1 1 1 1
Sobel : 2 masques 2D sont appliqués (Hx pour donner Gx et Hy pour donner Gy) :
-1 0 1 -1 -2 -1 La dérivée suivant la 4-Connexité

Hx = -2 0* 2 Hy = 0 0* 0 est privilégiée par rapport au
-1 0 1 1 2 1 masque de Prewitt.
Kirsch : 8 masques 2D sont appliqués (H0 à H7 pour donner G0 à G7) :
Le gradient est calculé sur 8 directions.

La norme du gradient est entière. La direction du gradient est donnée dans le code de Freeman.
- norme du gradient : G [ x, y ] = Sup Gi [x, y ] avec : Gi [x, y ] = H i [x, y ] ∗ IM [x, y ]

pour i = 0→7
- direction du gradient : D[x, y ] = i (i ∈ [0,7 ]) tel que Gi [x, y ] = Sup G k [ x, y ]

pour k = 0 →7
5 5 5 -3 5 5 -3 -3 5 -3 -3 -3
H0= -3 0 -3 H1= -3 0 5 H2= -3 0 5 H3= -3 0 5
-3 -3 -3 -3 -3 -3 -3 -3 5 -3 5 5
-3 -3 -3 -3 -3 -3 5 -3 -3 5 5 -3
H4= -3 0 -3 H5= 5 0 -3 H6= 5 0 -3 H7= 5 0 -3
5 5 5 5 5 -3 5 -3 -3 -3 -3 -3
3. 7
Masques utilisés pour le laplacien :
On pourra utiliser, pour le cacul du laplacien, l’un des 3 masques Hi suivants, ces masques donnant des résultats
similaires :
Image résultat L : (point(x,y) considéré) : L[x, y ] = H i [x, y ] ∗ IM [x, y ] :

0 -1 0 -1 -1 -1 1 -2 1
H1= -1 4 -1 H2= -1 8 -1 H3= -2 4 -2
0 -1 0 -1 -1 -1 1 -2 1
Le gradient peut être calculé et approché de nombreuses façons, réalisant ainsi différents compromis entre précision et
temps calcul :
- Module (pour un point (x,y) considéré):
G[x, y ] = G x2 [x, y ] + G y2 [x, y ] (formule vraie)

ou :
(
G[x, y ] = Sup G x [x, y ] , G y [x, y ] ) (approximation)
ou :
G [x , y ] = G x [ x , y ] + G y [ x , y ] (approximation)
etc...
- Direction (pour un point (x,y) considéré) :
G y [x , y ]
D[x, y ] = Arctg
G x [x , y ]
(formule vraie)
ou : (approximation dans le code de Freeman (4 directions utilisées)) :
(
0 (code de Freeman) si G x [x, y ] = Sup G x [x, y ] , G y [x, y ] ) [ ]
et G x x, y ≥ 0
(
4 (code de Freeman) si G x [x, y ] = Sup G x [x, y ] , G y [x, y ] ) [ ]
et G x x, y < 0
D [x , y ] =
(
6 (code de Freeman) si G y [x, y ] = Sup G x [x, y ] , G y [x, y ] ) [ ]
et G y x, y ≥ 0
(
2 (code de Freeman) si G y [x, y ] = Sup G x [x, y ] , G y [x, y ] ) [ ]
et G y x, y < 0
etc...
3. 8
Opérateur Gradient à 4 différences (détermination rapide et efficace du gradient permettant d'obtenir des contours fins)
Opérateur à appliquer sur l’image en niveaux de gris lissée.
Une méthode rapide et efficace pour le calcul du gradient, donnant des contours fins, consiste à appliquer un masque
2x2 au pixel courant (noté *) de coordonnées (x,y) , et de calculer les 4 différences ∆ i [ x, y ] (i = 0 à 3) :
g1 g2 g1 g2 g1 g1 g2
g2
g3 g4 * * * *
g3 g4 g3 g4 g3 g4
∆ 0 [ x, y ] = g 4 − g 3 ∆1[ x, y ] = g 2 − g 3 ∆ 2 [ x, y ] = g 2 − g 4 ∆3[ x, y ] = g1 − g 4
( * : pixel central d'application du masque (x,y) )
gi (i=0 à 3) : niveau de gris d'un pixel
- norme du gradient (donnée en entier) (pour un point (x,y) considéré) : (correspond ici à l’étendue dans le voisinage)
G [x , y ] = Sup ∆ i [x , y ]
pour i = 0 → 3
- direction du gradient (donné dans le code de Freeman) (point (x,y) considéré) : (direction donnée non pas au degré près mais
parmi 8 directions)
i si ∆ i [x , y ] = Sup ∆i [x, y ] et ∆ i [x , y ] ≥ 0
D[x, y ] =
pour i = 0 → 3
i + 4 si ∆ i [x , y ] = Sup ∆ i [x , y ] [ ]
et ∆ i x, y < 0
pour i = 0 → 3
3 2 1
4 0
5 6 7
Codage de Freeman
Remarque concernant la direction du gradient :
La direction du gradient est perpendiculaire à la direction du contour.

En effet une transition horizontale engendre un contour vertical :
→
0 255
Le gradient correspond aux lignes de crête :
G
C
: contour considéré
G : direction du gradient : ou
C : direction du contour : ou
On a la relation, dans le codage de Freeman :

 
direction i du contour =  direction j du gradient ± 2  modulo 8 i et j ∈ [0,7]
 
3. 9
Suppression des non maxima locaux du gradient :
Cette dernière étape, optionnelle dans la détection des contours, est destinée à éliminer les discontinuités et amincir les
lignes de contour.
Le principe est le suivant :

Soit :
M[x,y] : le pixel de coordonnées (x,y) de l'image du module du gradient.
D[x,y] : le pixel de coordonnées (x,y) de l'image de la direction du gradient.
Pour chaque point (x,y), on détermine les points adjacents (en 8-connexité) qui se trouvent dans la direction du gradient :
M[x2,y2]
Contour
M[x,y]
Direction du gradient
M[x1,y1]
L'algorithme est alors très simple :
/* Amincissement */
Pour tout point [x,y] de l'image
Si (M[x,y] > M[x1,y1]) et (M[x,y] > M[x2,y2]) alors M[x,y] est conservé
sinon M[x,y] = 0 /* M[x,y] est supprimé */
 x1 , y1 
Soit D l’image de la Direction du Gradient. Pour obtenir les points dans la direction du Gradient   , on peut
 x2 , y2 
utiliser les tableaux suivants: ∆x Τ = [1 1 0 − 1 − 1 − 1 0 1] et ∆y Τ = [0 − 1 − 1 − 1 0 1 1 1]
et l’algorithme :
i = D ( x, y )
x1 ← x + ∆xi
y1 ← y + ∆yi
x 2 ← x + ∆x(i+ 4) modulo 8
y 2 ← y + ∆y( i+ 4) modulo 8
/* Elimination des discontinuités dans les contours */

L'élimination des discontinuités des contours peut s'obtenir ensuite en mettant à 0 les chaînes de contour adjacents dans
une direction donnée (la direction suivie) ayant une longueur (valeur des amplitudes M[xi,yi] non nulle, ou non annulée
par l'amincissement précédent) inférieure à un certain seuil fixé préalablement.
3. 10
Opérateur de Deriche (voir Annexe pour plus de détails)
Filtre de Deriche - Principe
Deriche a recherché l'opérateur détecteur (≡ dérivateur) optimal sous la forme d'un filtre RII de RI f(x) de la forme :
f ( x ) =S .x.e
−α x
filtre 1D détecteur (dérivateur) de Deriche
avec: S: constante de normalisation et α: paramètre du filtre.

(S<0 pour que la RI ait l'allure voulue, permettant la détection (convolution maximale à l'endroit de la transition).
Entrée 1D e(x) (saut bruité)
0 x
Détecteur f(x)
0 x
Sortie : f(x) * e(x)
x
0
- le filtre est bien sûr discrétisé, ( f(x) → f(n) avec n: discret [n=mT avec m entier et T réel (période d'échantillonage)
pris à 1 ici → T "égal" à la résolution de l'image] et f(n) à valeurs discrètes ), et il est mis en oeuvre de façon récursive
pour éviter les erreurs de troncature du filtre.
- la séquence discrète h(n) de l'intégrale continue h(x) de f(x) est utilisée comme RII de la fonction de lissage préalable
avant la détection :
h(n ) =k .(α n + 1).e
−α n
filtre 1D de lissage de Deriche
avec : k : constante de normalisation.
- Normalisation :
∞ 0
f (n) : ∑ f (n ) = − ∑ f (n ) = −1
n =0 n = −∞
∞
on a : ∑ f (n ) = − 1
n =0
et non 1, car f(n) < 0 pour n > 0.
∞
on a bien : ∑ f (n ) =0
n = −∞
car f(n) est un dérivateur (∑poids du masque = 0).
∞
h(n) : ∑ h(n) = 1
n = −∞
le filtre h(n) est un filtre de lissage : ∑poids du masque = 1, pour garder la même dynamique qu'avant filtrage.
3. 11
- Algorithme (étapes)
1. lissage en y * dérivation en x → gradient récursif en x : Gx (* : convolution)

2. lissage en x * dérivation en y → gradient en y : Gy
3. gradient :
norme: G = = Gx 2 + Gy 2
+ direction : D = Arctg (Gy / Gx )
4. suppression des non maximas locaux du gradient.
5. seuillage de la norme du gradient pour donner les contours.
Algorithme du filtre de Deriche 1D
−α n
Equations du filtre dérivateur 1D f(n) : f (n) = Sne (RI)
 y + (n) = x (n − 1) − b1 y + (n − 1) − b2 y + ( n − 2) pour : n ="1" → N

 − − −
 y (n) = x( n + 1) − b1 y ( n + 1) − b2 y ( n + 2) pour : n =" N " → 1

{ + −
 y ( n) = a y ( n) − y ( n) } pour : n = 1 → N N points (1 ligne d' image = N points)
(1 − e −α ) 2
avec : S=− ; a = Se − α ; b = −2e − α ; b = e − 2α .
e −α 1 2
−α n
Equations du filtre de lissage 1D h(n) : h(n) = K .(α n + 1).e (RI)
 y + ( n) = a 0 x( n) + a1 x( n − 1) − b1 y + ( n − 1) − b2 y + (n − 2) pour : n ="1" → N
 − − −
 y ( n) = a 2 x( n + 1) + a 3 x( n + 2) − b1 y (n + 1) − b2 y ( n + 2) pour : n =" N " → 1
 + −
 y (n) = y (n) + y ( n) pour : n = 1 → N N points (1 ligne d' image = N points)
avec :
(1 − e −α ) 2
K=
a0 = K a = K (α − 1)e − α b = −2e − α b = e − 2α
1 + 2αe −α − e − 2α ; ; 1 ; 1 ; 2 ;
a 2 = a1 − Kb1 ; a3 = − Kb2
.
On en déduit l'algorithme du filtre de Deriche 2D (pour images) :
3. 12
Algorithme du filtre de Deriche 2D
1. Calcul récursif du gradient lissé en x : Gx(x,y) :

Gx = (fx * IM) * hy = S * hy en posant : S = fx * IM IM: image initiale de taille Nx*Ny
1a. Calcul de S = fx * IM : (S :temporaire) S = fx * IM (→ et ← )
 +  x ="1" → N x 
S ( x, y ) = IM ( x − 1, y ) − b1S ( x − 1, y ) − b2 S ( x − 2, y )
+ +
y = 1 → N 
  y 

 −  x =" N x " → 1
S ( x, y ) = IM ( x + 1, y ) − b1S ( x + 1, y ) − b2 S ( x + 2, y )
− −
y = → N 
  1 y 

x = 1 → N x 
{ }
S(x, y ) = a S + ( x, y ) − S − ( x, y )
 y = 1→ N 
 y
1b. Caclul de Gx = S * hy : Gx = S * hy (↓ et ↑ )
 + x :1 → N x 
G ( x, y ) = a 0 S( x, y ) + a1S( x, y - 1) − b1G ( x, y − 1) − b2 G ( x, y − 2 )
+ +
 y :"1" → N 
  y

 − x :1 → N x 
G ( x, y ) = a 2 S( x, y + 1) + a3 S( x, y + 2 ) − b1G ( x, y + 1) − b2 G ( x, y + 2 )
− −
 y :" N " → 1
  y 

G ( x, y ) = G − ( x, y ) + G + ( x, y ) x = 1 → N x 
 x y = 1→ N 
 y
2. Calcul récursif du gradient lissé en y : Gy(x,y) :

Gy = (fy * IM) * hx = S * hx en posant : S = fy * IM
2a. Calcul de S = fy * IM : (S : temporaire) S = fy * IM (↓ et ↓ )
 + x = 1 → N x 
S ( x, y ) = IM ( x, y − 1) − b1S ( x, y − 1) − b2 S ( x, y − 2 )
+ +
 y ="1" → N 
  y

 − x = 1 → N x 
S ( x, y ) = IM ( x, y + 1) − b1S ( x, y + 1) − b2 S ( x, y + 2 )
− −
 y =" N " → 1
  y 

x = 1 → N x 
{ }
S(x, y ) = a S + ( x, y ) − S − ( x, y )
 y = 1 → N 
 y
2b. Calcul de Gy = S * hx Gy = S * hx (→ et ← )
 +  x ="1" → N x 
G ( x, y ) = a 0 S( x, y ) + a1S( x − 1, y ) − b1G ( x − 1, y ) − b2 G ( x − 2, y )
+ +
y = 1→ N 
  y 

 −  x =" N " x → 1
G ( x, y ) = a 2 S( x + 1, y ) + a 3 S( x + 2, y ) − b1G ( x + 1, y ) − b2 G ( x + 2, y )
− −
y = 1→ N 
  y 
 x = 1 → N x 
G ( x, y ) = G − ( x, y ) + G + ( x, y )
 y y = 1→ N 
 y
3. 13
3. Calcul de la norme et de la direction du gradient : G(x,y) et D(x,y):
G(x,y) = G x2 ( x, y ) + G y2 ( x, y ) : norme du gradient.
 G y ( x, y ) 
D( x, y ) = Arctg  
( )
: direction du gradient.
G
 x x , y 
4. Suppression des non maximas locaux de la norme du gradient :
Elimination des non maximas locaux de la norme du gradient dans la direction du gradient.
5. Seuillage de l'image de la norme des gradients :
Sélection des points de l'image « norme des gradients » comme points de contours si la valeur v de leur norme du
gradient est telle que : v > Seuil.
→ l'image des contours est alors obtenue.
__________
3. 14
Traitement d'Images TP 3. Segmentation des images
TP 3. Segmentation des images (pelvis ou hand)
1. Détection des contours

Lecture N&B :
I := READ_IMAGE( "pelvis.jpg" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 420 Ny = 367
Lissage (moyenne, médian, Nagao ...) : J := Moyenne( I) ou J := Nagao( I)
Gradient à 4 différences : Recadrage Dynamique : Seuillage :

K := NormeGradient4Diff ( J) L := RecadrageDyn%( K , 0 , 50) M := Binarisation ( K , 10)
N := DirGradient4Diff ( J)
Codage des couleurs de l'image de Direction du Gradient : r := Rvb( N) v := rVb( N) b := rvB( N)

Direction 2 = N = Bleu
Direction 3 = NO = Orange Direction 1 = NE = Vert
Direction 4 = O = Magenta Direction 0 = E = Rouge
Direction 5 = SO = Kaki Direction 7 = SE = Jaune
Direction 6 = S = Cyan
Originale Lissée
I J
TP 3 Corrigé. 1
Norme Gradient Norme Gradient amplifiée
K L
Norme Gradient seuillée (Contours) Direction Gradient
M r , v, b
TP 3 Corrigé. 2
Suppression des non maxima locaux du gradient (amincissement) : Gradient 4 diff : K2 := SuppressionNonMaximaLocaux( K , N)
Recadrage Dynamique : L2 := Ampli( K2 , 8 ) Seuillage : M2 := Binarisation ( K2 , 13)
Originale Lissée
I J
Norme Gradient amplifiée Norme Gradient seuillée (Contours)
L M
TP 3 Corrigé. 3
Norme Gradient amplifiée (Suppression non maxima) Norme Gradient seuillée (Contours) (Suppression non maxima)
L2 M2
TP 3 Corrigé. 4
Fonctions Bibliothèque :
Histo( I) ≡ for n ∈ 0 .. 255 RecadrageDyn( I) ≡ H ← Histo( I)

H ←0 for i ∈ 0 .. 255
n
for y ∈ 0 .. rows( I) − 1 i
for x ∈ 0 .. cols( I) − 1 for i ∈ 255 , 254 .. 0
n←I mini ← i if H ≠ 0
y, x i
H ←H +1 255
n n ∆←
maxi − mini
H
for y ∈ 0 .. rows( I) − 1
255
RecadrageDyn%( I , nb , nh) ≡ ∆← for x ∈ 0 .. cols( I) − 1
nh − nb
( y , x )
for y ∈ 0 .. rows( I) − 1 J ← round  I − mini ⋅ ∆
y, x 
for x ∈ 0 .. cols( I) − 1 J
( y , x )
J ← round  I − nb ⋅ ∆
y, x 
J
Convol3x3( I , Mask3x3) ≡ for y ∈ 1 .. rows( I) − 2

for x ∈ 1 .. cols( I) − 2
som ← 0
for i ∈ 0 .. 2
for j ∈ 0 .. 2
som ← som + round I ( y+i−1 , x+ j−1⋅ Mask3x3i, j)
som ← 255 if som > 255
som ← 0 if som < 0
J ← som
y, x
J
Derivation ( I , Mask3x3) ≡ for y ∈ 1 .. rows( I) − 2

for x ∈ 1 .. cols( I) − 2
som ← 0
for i ∈ 0 .. 2
for j ∈ 0 .. 2
som ← som + I ⋅ Mask3x3
y+i− 1 , x+ j− 1 i, j
som ← som
som ← 255 if som > 255
J ← som
y, x
J
TP 3 Corrigé. 5
Binarisation ( I , seuil ) ≡ for y ∈ 0 .. rows( I) − 1 T2D( I) ≡ for y ∈ 0 .. rows( I) − 1

for x ∈ 0 .. cols( I) − 1 for x ∈ 0 .. cols( I) − 1
J ← 0 if I < seuil J ←I
y, x y, x y, x y, x
J ← 255 otherwise J
y, x
J
T1DColonne( I , f ) ≡ for n ∈ 0 .. rows( I) − 1 T1D( I) ≡ for x ∈ 0 .. cols( I) − 1
g ←f 〈x〉
n n f ←I
g 〈x〉
return J
Median( I) ≡ for y ∈ 1 .. rows( I) − 2
for x ∈ 1 .. cols( I) − 2
for i ∈ 0 .. 2 ET( x , y) ≡ 0 if x = 0 OU( x , y) ≡ 1 if x = 1
for j ∈ 0 .. 2 0 if y = 0 1 if y = 1
v ←I 1 otherwise 0 otherwise
3⋅ i+ j y+i− 1 , x+ j− 1
vtri ← sort ( v)
J ← vtri
y, x 4
J 1 1 1
9 9 9
 
Moyenne( I) ≡ M ← 
1 1 1
9 9 9
1 1 1
 
9 9 9
J ← Convol3x3( I , M )
J
Dilatation( I) ≡ for y ∈ 1 .. rows( I) − 2 DilatationGris ( I) ≡ for y ∈ 1 .. rows( I) − 2

for i ∈ 0 .. 2 for i ∈ 0 .. 2
for j ∈ 0 .. 2 for j ∈ 0 .. 2
I v ←I
y+ i−1 , x+ j−1 3⋅ i+ j y+ i− 1 , x+ j− 1
v ←
3⋅ i+ j 255 J ← max( v)
y, x
Test ← v
0 J
for i ∈ 1 .. 8
Test ← v ∨ Test if i ≠ 4
i
J ← 255 if Test = 1
y, x
J ←I otherwise
y, x y, x
J
TP 3 Corrigé. 6
Erosion ( I) ≡ for y ∈ 1 .. rows( I) − 2 ErosionGris( I) ≡ for y ∈ 1 .. rows( I) − 2

for i ∈ 0 .. 2 for i ∈ 0 .. 2
for j ∈ 0 .. 2 for j ∈ 0 .. 2
I v ←I
y+ i− 1 , x+ j− 1 3⋅ i+ j y+ i− 1 , x+ j− 1
v ←
3⋅ i+ j 255 J ← min( v)
y, x
Test ← v
0 J
for i ∈ 1 .. 8
Test ← v ∧ Test if i ≠ 4
i
J ←I if Test = 1
y, x y, x
J ← 0 otherwise
y, x
J
NormeGradient4Diff ( I) ≡ for y ∈ 1 .. rows( I) − 2 Ampli( I , gain) ≡ for y ∈ 0 .. rows( I) − 1
r←I ⋅ gain
y, x
J ←r
y, x
J ← 255 if r > 255
y, x
J ← 0 if r < 0
y, x
J
NormeGradient
IndiceMax( v) ≡ N ← length ( v)
DirGradient4Diff ( I) ≡ for y ∈ 1 .. rows( I) − 2 IndiceMax ← 0
for x ∈ 1 .. cols( I) − 2 Max ← v
0
for i ∈ 1 .. N − 1
if v > Max
i
Max ← v
i
IndiceMax ← i
IndiceMax
DirGradient
TP 3 Corrigé. 7
Codage RVB de la Direction du Gradient :

Noir (RVB=0,0,0) Blanc (RVB=255,255,255) Gris (RVB=127,127,127)
Rouge (RVB=255,0,0) Magenta (RVB=255,0,255) Marron(127,0,0)
Vert (RVB=0,255,0) Kaki (RVB=127,127,0)
Bleu (RVB=0,0,255) Cyan (RVB=0,255,255) Violet (RVB=127,0,127)
Jaune (RVB=255,255,0) Orange (RVB=255,127,0)
Rvb ( I) ≡ for y ∈ 0 .. rows( I) − 1 rVb( I) ≡ for y ∈ 0 .. rows( I) − 1 rvB( I) ≡ for y ∈ 0 .. rows( I) − 1
for x ∈ 0 .. cols( I) − 1 for x ∈ 0 .. cols( I) − 1 for x ∈ 0 .. cols( I) − 1
R ← 255 if I =0 V ← 0 if I =0 B ← 0 if I =0
y, x y, x y, x y, x y, x y, x
R ← 0 if I =1 V ← 255 if I =1 B ← 0 if I =1
R ← 0 if I =2 V ← 0 if I =2 B ← 255 if I =2
R ← 255 if I =3 V ← 127 if I =3 B ← 0 if I =3
R ← 255 if I =4 V ← 0 if I =4 B ← 255 if I =4
R ← 127 if I =5 V ← 127 if I =5 B ← 0 if I =5
R ← 0 if I =6 V ← 255 if I =6 B ← 255 if I =6
R ← 255 if I =7 V ← 255 if I =7 B ← 0 if I =7
R V B
T T
∆x ≡ ( 1 1 0 −1 −1 −1 0 1 ) ∆y ≡ ( 0 −1 −1 −1 0 1 1 1 )
SuppressionNonMaximaLocaux( M , D) ≡ for y ∈ 1 .. rows( M ) − 2

for x ∈ 1 .. cols( M ) − 2
TP 3 Corrigé. 8
0 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 0
0 0 0 1 1
 0 0 1 1 0
 0 1 1 0 0
 1 1 0 0 0

       
D ≡ 0 0 1 1 1 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 1 1 1 0 0
1 2 3 4
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
       
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0

       
D ≡ 1 1 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 1 1
5 6 7 8
1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1
       
1 0 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 1
Chanda( I) ≡  for y ∈ 2 .. rows( I) − 3 

 for x ∈ 2 .. cols( I) − 3 
 
 SDG ← 0 
 SG ← 0 
 
for k ∈ 1 .. 8
 
 S←0 
 for j ∈ 0 .. 4 
 
 for i ∈ 0 .. 4 
 S ← S + I ⋅(D )  
  y+ j−2 , x+i−2 k j , i 
 S 
 S← 
6
 
 S2 ← 0 
 for j ∈ 0 .. 4 
 
 for i ∈ 0 .. 4 
 
y+ j− 2 , x+ i−2 ( k) j , i
2
S2 ← S2 +  I ⋅ D
   
 
 S2 ←
S2 
 6 
 D←S−I 
 y, x 
 1 
 
( )
2
 G ← S2 − S
2 
 
 SDG ← SDG + D⋅ G 
 SG ← SG + G 
 
SDG
 J ←I − 
y, x y, x
 SG 
 J ← 0 if J <0 
y, x y, x
 
 J
y, x
← 255 if J
y, x
> 255 
 
 J 
TP 3 Corrigé. 9
 
0 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 0
0 0 0 1 1
 0 0 1 1 0
 0 1 1 0 0
 1 1 0 0 0

       
D ≡ 0 0 1 1 1 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 1 1 1 0 0
1 2 3 4
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
       
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0

       
D ≡ 1 1 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 1 1
5 6 7 8
1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1
       
1 0 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 1
ChandaV( I) ≡  for y ∈ 2 .. rows( I) − 3 

 
 for x ∈ 2 .. cols( I) − 3 
 SDG ← 0 
 SG ← 0 
 
 for k ∈ 1 .. 8 
 S←0 
 for j ∈ 0 .. 4

 
 for i ∈ 0 .. 4 
y+ j−2 , x+ i− 2 ( k) j , i
 S ← S + I ⋅ D 
   
 S 
 S← 
 6 
 2 
S
 S2 ← 
 6 
 D←S−I 
y, x
 
 1 
 
( )
2
 G ← S2 − S
2 
 
SDG ← SDG + D⋅ G
 
 SG ← SG + G 
 SDG 
 J
y, x
←I
y, x
− 
SG
 
 J
y, x
← 0 if J
y, x
<0 
 
 J ← 255 if J > 255 
y, x y, x
 
 J 
TP 3 Corrigé. 10
Nagao( I) ≡ for y ∈ 2 .. rows( I) − 3

for x ∈ 2 .. cols( I) − 3
for j ∈ 0 .. 2
for i ∈ 0 .. 2
for m ∈ 0 .. 2
for k ∈ 0 .. 2
Tmp ←I
m⋅ 3+ k y+ j+ m− 2 , x+ i+ k− 2
Moy ← mean( Tmp ) if i⋅ j ≠ 1
3⋅ j+ i
Moy ← 0 otherwise
3⋅ j+ i
Var ← max( Tmp ) − min( Tmp ) if i⋅ j ≠ 1
3⋅ j+i
Var ← 255 otherwise
3⋅ j+i
Mini ← min( Var)
for i ∈ 0 .. 8
W ← Moy if Var = Mini
y− 2 , x− 2 i i
W
__________
TP 3 Corrigé. 11
Traitement d'images 4. Images Bi-niveaux - Opérateurs Morphologiques
4. Images Bi-Niveaux - Opérateurs Morphologiques
1. Images Bi-niveaux
Dans tout ce chapitre, on partira d'images bi-niveaux, c'est-à-dire avec une dynamique réduite à 2 niveaux. Elles peuvent
être obtenues à partie d'images en niveaux de gris par binarisation (seuillage).
Avantage : réduction de la quantité d'informations de l'image tout en conservant quasiment toutes les informations
pertinentes (nécessaires à sa compréhension).
2. Opérateurs Morphologiques
On part de l'image binaire.
On prend la convention : 0 = FAUX

(dynamique -1) = VRAI
On utilise un élément structurant (issu des études de morphologie mathématique) si on recherche une forme particulière
dans l’image.
Cet élément structurant est un masque dont les éléments forment un motif correspondant à la forme de l’objet recherché
dans l’image.
L'application de l'opérateur consiste à balayer l'image avec le masque et à effectuer pour chaque pixel une mise en
correspondance du pixel et de ses voisins avec le motif du masque,
et d'en effectuer l'union ou l'intersection (Template matching).
1 = Objet 0 = Fond par exemple.
Exemple :
Elémént structurant image originale union intersection

(3x3)
0 1 0 0 1 0 0 1 0 0 1
0 1 1 0 0 0 0 1 1 0 0 0
0 1 0 0 1 0 0 1 0 0 1
1=vrai
0=faux
3. Dilatation - Erosion - Squelettisation
Binarisation → zones blanches avec points noirs isolés.

sur image bruitée et zones noires avec points blancs isolés.
But :
Dilatation → suppression des points noirs isolés.

Erosion → suppression des points blancs isolés.
4. 1
Ces procédures influent sur la taille des objets de l'image (d'où leur nom).
Pour éliminer points noirs et points blancs, on applique généralement une Dilatation / Erosion suivie d'une Erosion /
Dilatation.
(nombre d'érosions = nombre de dilatations → taille des objets conservée)
3.1. Dilatation
On prend une fenêtre de taille nxn (n impair, exemple : n = 3).
On effectue pour chaque pixel le OU logique de ses (n2 - 1) voisins (c'est à dire tous les pixels de la fenêtre sauf le point
central).
Le résultat est : VRAI (≡ dynamique - 1) si le OU logique est VRAI.

pixel original si le OU logique est FAUX.
Algorithme de la Dilatation :
Début
 Pout tout point (x,y) de l'image IM Faire
 Calculer OU(x,y) : OU entre les (n2 - 1) voisins du point (x,y) central
  Si OU(x,y) alors WM[x,y] = VRAI /* OU(x,y) ≡ [OU(x,y) = VRAI] */
  Sinon WM[x,y] = IM[x,y] /* Recopie */
  Fsi
 Fp
Fin
IM : image originale; WM : image traitée
Résultats de la Dilatation sur une fenêtre de taille nxn = 3x3 :
1- Dilatation des points blancs :
0 0 0 0 0 0 0 . . . . . . .
0 0 0 0 0 0 0 . 0 0 0 0 0 .
0 0 0 0 0 0 0 . 0 1 1 1 0 .
0 0 0 1 0 0 0 → . 0 1 1 1 0 .
0 0 0 0 0 0 0 . 0 1 1 1 0 .
0 0 0 0 0 0 0 . 0 0 0 0 0 .
0 0 0 0 0 0 0 . . . . . . .
2- Elimination des points noirs :
1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 0 1 1 1 → 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1
4. 2
3.2. Erosion
On effectue cette fois le ET logique des (n2 - 1) voisins du pixel courant :
Algorithme de l'Erosion :
Début
 Pout tout point (x,y) de l'image IM Faire
 Calculer ET(x,y) : ET entre les (n2 - 1) voisins du point (x,y) courant
  Si ET(x,y) alors WM[x,y] = IM[x,y] /* Recopie */
  Sinon WM[x,y] = FAUX
  Fsi
 Fp
Fin
IM : image originale; WM : image traitée
Résultats de l'Erosion :
0 0 0 0 0 0 0 0 0 0 0 0 0 0 Elimination des points blancs

0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 → 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 . . . . . . . Dilatation des points noirs

1 1 1 1 1 1 1 . 1 1 1 1 1 .
1 1 1 1 1 1 1 . 1 0 0 0 1 .
1 1 1 0 1 1 1 → . 1 0 0 0 1 .
1 1 1 1 1 1 1 . 1 0 0 0 1 .
1 1 1 1 1 1 1 . 1 1 1 1 1 .
1 1 1 1 1 1 1 . . . . . . .
3.3. Axe médian
On part toujours de l'image binarisée.
L’amincissement a pour but d'extraire les "lignes de forces de l'image" (squelette, axe médian).
Axe médian = succession d'amincissements jusqu'à ce que l'image traitée soit stable (plus aucune modification effectuée).
→ l'image finale (le motif) a une épaisseur d'un pixel.
4. 3
Définitions
Le squelette d'un objet est un graphe (et donc plus qu'un ensemble de points) caractéristique de la forme de cet objet, et
qui peut (transformation réversible) permettre de la reconstituer le cas échéant. C'est une forme de condensation de
l'information utilisée en particulier pour l'identification de caractères manuscrits ou typographiques, car tous les
caractères squelettisés ont alors la même épaisseur → plus grande facilité de reconnaissance.
Deux définitions très proches du squelette utilisent une représentation continue et non discrète de l'espace x,y :
- Le squelette est le lieu des centres des disques de rayon maximum inscrits dans l'objet. Tout l’objet doit être traité.
Connaissant le rayon associé à chaque point il est donc possible de reconstruire l'objet.
La définition du squelette provoque un effet de fourche
- L'axe médian est l'ensemble des points équidistants de deux bords de l'objet: c'est l'image du "feu de prairie" où l'axe
médian est le lieu de rencontre des fronts de flammes à propagation circulaire :
La définition de l’axe médian ne provoque pas d’effet de fourche
Axe médian
Principe
Balayage de l'image avec une série de 8 masques décrivant les différentes formes possibles d'une ligne sur 3 pixels :
(points 2, 3 et 4 des masques) : la ligne en question est l'axe médian à obtenir;
L’amincissement va supprimer le pixel central d’application du masque (pixel 1), c’est-à-dire le petit bout à partir du
pixel 1 dans les configurations suivantes :
5 2 6 5 4 7 3 4
6 1 3 7 1 2 3 1 6 2 1 7
7 4 4 3 2 5 5 6
7 6 5 7 6 2 3 4 2 3
1 4 1 5 1 5 1
4
4 2 3 2 5 6 7 6 7
3
Masques utilisés pour l'amincissement
4. 4
Une fonction logique F est utilisée à cet effet, pour ne retenir sur une image que son axe médian pour une configuration
donnée :
F = (1.2.3.4). ( 5.6.7 )
= (1.2.3.4). (5 + 6 + 7 ) (. = ET ; + = OU = complément)
Remarque : on peut se limiter à F = (2.3.4). ( 5.6.7 ) si on part d’un pixel courant faisant partie de l’objet (conseillé
puisque le but est d’amincir).
Les points 5,6 et 7 des masques servent à tester si le pixel 1 n'appartient pas déjà à une ligne, auquel cas il ne faut pas le
supprimer. Cela permet, si c'est le cas, de garder celle-ci intacte. La présence des 8 masques s'explique par le fait que
l'opérateur ne doit pas privilégier une direction particulière, mais amincir l'image suivant toutes les directions de manière
isotrope.
Pour effectuer la squelettisation, il suffit d'appliquer plusieurs fois l'opérateur d'amincissement précédemment décrit
jusqu'à obtention du squelette (stabilisation) :
Algorithme de l'Axe médian

Début Procédure Amincissement
Stable = FAUX Début
Tant que Image NON Stable Faire Stable VRAI
Amincissement Pour chaque point (x,y) de l'image IM Faire
Ftq Pour chacun des 8 masques Faire
Fin Calculer F
Si F alors { WM[x,y] = 0; Stable = FAUX; Break }
Sinon WM[x,y] = IM[x,y] Recopie
Fsi
Fp
Fp
Fin
L’axe médian s’obtient après une succession d'opérations appelées amincissements jusqu'à obtention d'une structure
stable ne pouvant plus être amincie, c'est à dire dont les éléments sont des lignes d'une épaisseur d'un pixel (épaisseur
unitaire).
3.4. Squelettisation
Cette opération est une étape essentielle de la reconnaissance de forme. Elle a pour but de décrire chaque objet par un
ensemble de lignes unitaires (≡ d’épaisseur 1 pixel) (analogues à une ossature de l'objet), réduisant sensiblement le
volume d'information à manipuler. Le squelette est généralement défini comme étant l'ensemble des lignes médianes,
c'est-à-dire l'ensemble des points équidistants de deux points de la frontière. L'obtention du squelette des images
mosaïques binaires peut conduire à des erreurs de connexité.
Les deux principales familles de méthodes procèdent par :
- calcul de la distance à la frontière : le squelette est l'ensemble des points qui sont des maxima locaux (ligne de crêtes)
- amincissement : l'objet est assimilé à un oignon épluché couche par couche de façon itérative, ou à une prairie sur le
pourtour de laquelle on allume un feu ; le squelette est le point de rencontre des fronts de feu.
4. 5
Algorithme
Le principe consiste à réduire l’épaisseur du motif à squelettiser dans les directions verticale, horizontale et diagonale par
étapes successives en réduisant à chaque fois l’épaisseur d’un pixel jusqu’à obtenir une épaisseur unitaire pour le motif.
Après cette étape d’épluchage, des barbules parasites subsistent et sont supprimés dans une 2nde phase (nettoyage).
• Epluchage
On considère que le pixel du fond est 0 et le pixel du motif 1. On balaye l'image avec les 16 masques 3x3 de la figure.
Pour chaque pixel du motif (les pixels du fond sont ignorés et inchangés), si l'une des configurations est vérifiée, le pixel
central est remplacé par 0, sinon le pixel du motif est inchangé. L'opération est réitérée jusqu'à stabilité.
• Nettoyage (à appliquer après les étapes d’épluchage)
Si les frontières de l'objet sont bruitées le squelette peut comporter beaucoup de barbules. Il convient d'appliquer alors
des post-traitements (même principe d’élimination du pixel de motif que pour l’épluchage, sauf que le nettoyage ne
compte qu’une seule passe).
Addenda (correctif) : - Dans le cas de la configuration 496 (correctif dû au sens de balayage →↓) : si le pixel situé immédiatement en-
dessous du pixel courant se trouve dans la configuration 286, il n’y a pas suppression du pixel courant.
- Dans le cas de la configuration 124 (correctif dû au sens de balayage →↓) : si le pixel situé immédiatement à droite
du pixel courant se trouve dans la configuration 454, il n’y a pas suppression du pixel courant.
Passes successives d’épluchage puis Passe de nettoyage
Note : le présent calcul d’indice de voisinage (valeur associée à chaque masque) calculé selon la formule :
8
v = ∑ 2 i ⋅ p i où pi = 1 (resp. 0) s’il y a présence (resp. absence) du pixel dans le voisinage,
i =1
i=1 i=2 i=3
i=8 i=4
i=7 i=6 i=5
présente l’inconvénient de comporter des « trous » (indices non utilisés) : 256 indices allant de l’indice 0 à l’indice 510.
7
Il aurait été plus judicieux de calculer l’index par la formule suivante, présentant 256 indices allant de 0 à 255 : v = ∑ 2 i ⋅ pi
i =0
i=0 i=1 i=2
i=7 i=3
i=6 i=5 i=4
4. 6
Résultat de la squelettisation
Résultats de l'amincissement :
Image Originale Image Squelettisée Image Originale Image Squelettisée
Les effets de fourche aux bords sont en accord avec la définition du squelette.
3.5. Vectorisation
Même ramenée à son squelette, une image binaire de 256x256 pixels occupe 8192 octets. La vectorisation consiste à
approximer le squelette (ou le contour) par une suite de segments de droites (ou par des arcs de courbes). On y gagne en
compacité et on se rapproche d'une description géométrique des objets. La topologie (connexité) des objets doit être
conservée au cours de l'opération.
Un algorithme de base se décompose en :
• Division
1. Considérer la liste des points du squelette (contour) comme une sous-liste unique ;
2. Pour chaque sous-liste, chercher le point le plus éloigné de chaque côté de la corde joignant les extrémités de la sous-
liste ;
3. Si toutes les sous-listes présentent un écart à la corde inférieur à un seuil donné, alors fin de l'algorithme ; sinon
diviser chaque sous-liste dont l'écart est supérieur au seuil au point le plus éloigné et recommencer à 2.
• Fusion
Les sous-listes sont chaînées pour reconstituer le squelette (contour) initial.
4. 7
4. Dilatation - Erosion sur des images en niveaux de gris

Algorithme d’érosion sur une image en niveaux de gris
Affecter au pixel courant, le min des niveaux de gris des pixels du voisinage (ex. : voisinage 3x3) (ou plus
(affectation non révursive).
généralement l’élément structurant plutôt que le voisinage)
Algorithme de dilatation sur une image en niveaux de gris

Affecter au pixel courant, le max des niveaux de gris des pixels du voisinage (ex. : voisinage 3x3) (ou plus
(affectation non récursive).
généralement l’élément structurant plutôt que le voisinage)
__________
4. 8
Traitement d'Images TP 4. Opérateurs morphologiques
TP 4. Opérateurs morphologiques
1. Opérateurs morphologiques
Lecture N&B :
I := READ_IMAGE( "croixb.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 140 Ny = 152
Dilatation :
Image originale Image dilatée
J := Dilatation( I)
Erosion :
Image originale Image érodée
J := Erosion ( I)
TP 4. 1
Axe Médian : J := AxeMedian( I) Image originale Image Axe Médian
I J
Squelettisation : J := Squelettisation ( I) Image originale Image squelettisée
I J
TP 4. 2
2. Opérateurs morphologiques (érosion, dilatation) sur images en niveaux de gris

Lecture N&B :
Nx = 147 Ny = 195
Dilatation :
Image originale Image dilatée
J := DilatationGris ( I)
Erosion :
I Image originale Image érodée
J := ErosionGris( I)
TP 4. 3

H ←0 for i ∈ 0 .. 255
n
for y ∈ 0 .. rows( I) − 1 i
for x ∈ 0 .. cols( I) − 1 for i ∈ 255 , 254 .. 0
y, x i
H ←H +1 255
n n ∆←
maxi − mini
H
for y ∈ 0 .. rows( I) − 1
for x ∈ 0 .. cols( I) − 1
( y , x )
J ← round  I − mini ⋅ ∆
y, x 
J
Convol3x3( I , Mask3x3) ≡ for y ∈ 1 .. rows( I) − 2

for x ∈ 1 .. cols( I) − 2
som ← 0
for i ∈ 0 .. 2
for j ∈ 0 .. 2
som ← 255 if som > 255
J ← som
y, x
J

for x ∈ 1 .. cols( I) − 2
som ← 0
for i ∈ 0 .. 2
for j ∈ 0 .. 2
y+i− 1 , x+ j− 1 i, j
som ← som
som ← 255 if som > 255
J ← som
y, x
J
TP 4. 4

y, x y, x y, x y, x
y, x
J

g ←f 〈x〉
n n f ←I
g 〈x〉
return J
for x ∈ 1 .. cols( I) − 2
for j ∈ 0 .. 2 0 if y = 0 1 if y = 1
3⋅ i+ j y+i− 1 , x+ j− 1
vtri ← sort ( v)
J ← vtri
y, x 4
J

for x ∈ 2 .. cols( I) − 3
for j ∈ 0 .. 2
for i ∈ 0 .. 2
for m ∈ 0 .. 2
for k ∈ 0 .. 2
Tmp ←I
m⋅ 3+ k y+ j+ m− 2 , x+ i+ k− 2
3⋅ j+ i
Moy ← 0 otherwise
3⋅ j+ i
3⋅ j+i
3⋅ j+i
Mini ← min( Var)
for i ∈ 0 .. 8
y− 2 , x− 2 i i
W
TP 4. 5
0 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 0
0 0 0 1 1
 0 0 1 1 0
 0 1 1 0 0
 1 1 0 0 0

       
D ≡ 0 0 1 1 1 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 1 1 1 0 0
1 2 3 4
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
       
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0

       
D ≡ 1 1 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 1 1
5 6 7 8
1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1
       
1 0 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 1

 for x ∈ 2 .. cols( I) − 3 
 
 SDG ← 0 
 SG ← 0 
 
for k ∈ 1 .. 8
 
 S←0 
 for j ∈ 0 .. 4 
 
 for i ∈ 0 .. 4 
 S ← S + I ⋅(D )  
  y+ j−2 , x+i−2 k j , i 
 S 
 S← 
6
 
 S2 ← 0 
 for j ∈ 0 .. 4 
 
 for i ∈ 0 .. 4 
 
y+ j− 2 , x+ i−2 ( k) j , i
2
S2 ← S2 +  I ⋅ D
   
 
 S2 ←
S2 
 6 
 D←S−I 
 y, x 
 1 
 
( )
2
 G ← S2 − S
2 
 
 SG ← SG + G 
 
SDG
 J ←I − 
y, x y, x
 SG 
 J ← 0 if J <0 
y, x y, x
 
 J
y, x
← 255 if J
y, x
> 255 
 
 J 
TP 4. 6
 
0 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 0
0 0 0 1 1
 0 0 1 1 0
 0 1 1 0 0
 1 1 0 0 0

       
D ≡ 0 0 1 1 1 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 1 1 1 0 0
1 2 3 4
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
       
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0

       
D ≡ 1 1 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 1 1
5 6 7 8
1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1
       
1 0 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 1

 
 for x ∈ 2 .. cols( I) − 3 
 SDG ← 0 
 SG ← 0 
 
 for k ∈ 1 .. 8 
 S←0 
 for j ∈ 0 .. 4

 
 for i ∈ 0 .. 4 
y+ j−2 , x+ i− 2 ( k) j , i
 S ← S + I ⋅ D 
   
 S 
 S← 
 6 
 2 
S
 S2 ← 
 6 
 D←S−I 
y, x
 
 1 
 
( )
2
 G ← S2 − S
2 
 
 
 SG ← SG + G 
 SDG 
 J
y, x
←I
y, x
− 
SG
 
 J
y, x
← 0 if J
y, x
<0 
 
 J ← 255 if J > 255 
y, x y, x
 
 J 
TP 4. 7
Dilatation( I) ≡ DilatationGris ( I) ≡
TP 4. 8
AxeMedian( I) ≡
TP 4. 9
Squelettisation ( I) ≡
TP 4. 10
Erosion ( I) ≡ ErosionGris( I) ≡
__________
TP 4. 11
Traitement d'images 5. Opérateurs sur images de contours
5. Opérateurs sur Images de Contours

1. Affinage des contours

But : rendre les contours de largeur unitaire.
On a déjà vu l'affinage des contours, avec les images binaires, par une technique de morphologie mathématique : la
squelettisation.
Une autre technique, plus adaptée aux images de contours, explore les différentes configurations de contours possibles :
(la technique d’amincissement par suppression des non maximas locaux du gradient vue précédemment n’est pas toujours applicable car elle
nécessite de disposer de l’image de la direction du gradient).
Algorithme de Chin & Wan (affine les contours)
1) Eliminer chaque point de contour de l'image qui est au centre de l’une au moins des 8 configurations Ci (i = 1 à 8) en
voisinage (3x3) suivantes :
0 0 0 0 1 x x 1 x  x 1 0
1 1* 1  0 1* 1  1 1* 1  1 1* 0
    
 x 1 x  0 1 x  0 0 0   x 1 0
Sud Est Nord Ouest
x 0 0 0 0 x x 1 x x 1 x
1 1* 0  0 1* 1  0 1* 1  1 1* 0 
   
 x 1 x   x 1 x  0 0 x   x 0 0 
SO SE NE NO
x : sans importance.
1 : point de contour. 0 : non point de contour.
* : point central d'application du masque.
2) Mais ne pas toucher à ce point de contour s’il coïncide avec l’une au moins des 2 configurations Di
(i =1 et 2) (1x4) et (4x1) suivantes :
0
1* 
[0 1* 1 0 ]  
1
 
0
3) Répéter les 2 étapes précédentes (faire plusieurs passes de l’opérateur) jusqu’à ce que plus aucun changement ne
soit opéré (image stable pour le résultat).
5. 1
Algorithme à base de LUT (table de look-up)
Amélioration : Utilisation d'une table de look-up (LUT) (Voisinage 3x3 / 1 seule passe / largeur unitaire)
- Principe
On examine chaque point de contour de l’image, pour lequel on considère le masque de voisinage 3x3 (256
configurations possibles). Le pixel central (point de contour) est supprimé ou gardé en fonction de la configuration dans
le voisinage 3x3 de telle sorte à affiner les contours (algorithme visuel au cac par cas des 256 configurations). Une table
de look-up mémorise les 256 décisions pour optimiser le temps de traitement.
- Codage d'un point (i) dans le voisinage 3x3 d'un point de contour (*)
abcisse de x2
abcisse de x3 3 2 1 abcisse de x1
abcisse de x4 4 * 0 abcisse de x0
abcisse de x5 5 6 7 abcisse de x7
abcisse de x6
- Calcul de l'index V dans la table LUT, pour un point de contour donné (*)
(calcul hors-ligne par balayage de toutes les configurations de voisinage possibles)
7 xi = 1 : si i est point de contour
V= ∑x 2
i=0
i
i
avec:
xi = 0 : sinon
- Remplissage (une fois pour toutes) du vecteur LUT

(dans la même passe que le calcul de l’index avec application de l’algorithme d’affinage)
- LUT[V] = 0 si V est associé à une configuration Ci d’affinage (cf. LUT d’affinage pages suivantes)
- LUT[V] = 1 sinon.
- Tout point de contour subit la transformation :

(calcul en ligne par balayage de l’image et utilisation de la LUT)
devient
Pixel contour (1) courant (*) → LUT[V] = Décision avec :
1 : garder le pixel courant (*)
Décision =
0 : supprimer le pixel courant (*)
- Table des 256 configurations pour la LUT d’affinage :

Légende
# : index de configuration : (256 configurations)
. pixel = point de contour dans le voisinage 3x3 noté : x
. pixel = non point de contour dans le voisinage 3x3 noté : -
. pixel central : point de contour (noté * )
. Décision (D) : 1 : garder le pixel central : * → *
0 : éliminer le pixel central : * → - .
L’affinage élimine aussi les pixels isolés.
5. 2
#V D
0 0 1 1 2 x 1 3 x 1
* * x * * x
4 x 1 5 x 1 6 x x 1 7 x x 0
* * x * * x
8 x 1 9 x 1 10 x x 1 11 x x 1
* * x * * x
12 x x 1 13 x x 1 14 x x x 1 15 x x x 0
* * x * * x
16 1 17 1 18 x 1 19 x 1
x * x * x x * x * x
20 x 1 21 x 0 22 x x 0 23 x x 0
x * x * x x * x * x
24 x 1 25 x 1 26 x x 1 27 x x 1
x * x * x x * x * x
28 x x 0 29 x x 0 30 x x x 0 31 x x x 0
x * x * x x * x * x
32 1 33 1 34 x 1 35 x 1
* * x * * x
x x x x
36 x 1 37 x 1 38 x x 1 39 x x 1
* * x * * x
x x x x
40 x 1 41 x 1 42 x x 1 43 x x 1
* * x * * x
x x x x
44 x x 1 45 x x 1 46 x x x 1 47 x x x 1
* * x * * x
x x x x
48 1 49 1 50 x 1 51 x 1
x * x * x x * x * x
x x x x
5. 3
52 x 0 53 x 0 54 x x 0 55 x x 0
x * x * x x * x * x
x x x x
56 x 0 57 x 1 58 x x 1 59 x x 1
x * x * x x * x * x
x x x x
60 x x 0 61 x x 0 62 x x x 0 63 x x x 0
x * x * x x * x * x
x x x x
64 1 65 0 66 x 1 67 x 0
* * x * * x
x x x x
68 x 1 69 x 0 70 x x 1 71 x x 0
* * x * * x
x x x x
72 x 1 73 x 1 74 x x 1 75 x x 1
* * x * * x
x x x x
76 x x 1 77 x x 0 78 x x x 1 79 x x x 0
* * x * * x
x x x x
80 0 81 0 82 x 1 83 x 0
x * x * x x * x * x
x x x x
84 x 0 85 x 0 86 x x 0 87 x x 0
x * x * x x * x * x
x x x x
88 x 0 89 x 0 90 x x 1 91 x x 0
x * x * x x * x * x
x x x x
92 x x 0 93 x x 0 94 x x x 0 95 x x x 0
x * x * x x * x * x
x x x x
96 1 97 0 98 x 1 99 x 0
* * x * * x
x x x x x x x x
100 x 1 101 x 0 102 x x 1 103 x x 0

* * x * * x
x x x x x x x x
5. 4
104 x 1 105 x 1 106 x x 1 107 x x 1

* * x * * x
x x x x x x x x
108 x x 1 109 x x 0 110 x x x 1 111 x x x 0

* * x * * x
x x x x x x x x
112 0 113 0 114 x 1 115 x 0

x * x * x x * x * x
x x x x x x x x
116 x 0 117 x 0 118 x x 0 119 x x 0

x * x * x x * x * x
x x x x x x x x
120 x 0 121 x 0 122 x x 1 123 x x 0

x * x * x x * x * x
x x x x x x x x
124 x x 0 125 x x 0 126 x x x 0 127 x x x 0

x * x * x x * x * x
x x x x x x x x
128 1 129 1 130 x 1 131 x 0

* * x * * x
x x x x
132 x 1 133 x 0 134 x x 1 135 x x 0

* * x * * x
x x x x
136 x 1 137 x 1 138 x x 1 139 x x 1

* * x * * x
x x x x
140 x x 1 141 x x 0 142 x x x 1 143 x x x 0

* * x * * x
x x x x
144 1 145 1 146 x 1 147 x 1

x * x * x x * x * x
x x x x
148 x 1 149 x 0 150 x x 1 151 x x 0

x * x * x x * x * x
x x x x
152 x 1 153 x 1 154 x x 1 155 x x 1

x * x * x x * x * x
x x x x
5. 5
156 x x 0 157 x x 0 158 x x x 1 159 x x x 0

x * x * x x * x * x
x x x x
160 1 161 1 162 x 1 163 x 1

* * x * * x
x x x x x x x x
164 x 1 165 x 1 166 x x 1 167 x x 1

* * x * * x
x x x x x x x x
168 x 1 169 x 1 170 x x 1 171 x x 1

* * x * * x
x x x x x x x x
172 x x 1 173 x x 1 174 x x x 1 175 x x x 1

* * x * * x
x x x x x x x x
176 1 177 1 178 x 1 179 x 1

x * x * x x * x * x
x x x x x x x x
180 x 1 181 x 0 182 x x 1 183 x x 0

x * x * x x * x * x
x x x x x x x x
184 x 1 185 x 1 186 x x 1 187 x x 1

x * x * x x * x * x
x x x x x x x x
188 x x 1 189 x x 0 190 x x x 1 191 x x x 0

x * x * x x * x * x
x x x x x x x x
192 1 193 0 194 x 1 195 x 0

* * x * * x
x x x x x x x x
196 x 1 197 x 0 198 x x 1 199 x x 0

* * x * * x
x x x x x x x x
200 x 1 201 x 1 202 x x 1 203 x x 1

* * x * * x
x x x x x x x x
204 x x 1 205 x x 0 206 x x x 1 207 x x x 0

* * x * * x
x x x x x x x x
5. 6
208 0 209 0 210 x 1 211 x 0

x * x * x x * x * x
x x x x x x x x
212 x 0 213 x 0 214 x x 0 215 x x 0

x * x * x x * x * x
x x x x x x x x
216 x 0 217 x 0 218 x x 1 219 x x 0

x * x * x x * x * x
x x x x x x x x
220 x x 0 221 x x 0 222 x x x 0 223 x x x 0

x * x * x x * x * x
x x x x x x x x
224 0 225 0 226 x 1 227 x 0

* * x * * x
x x x x x x x x x x x x
228 x 1 229 x 0 230 x x 1 231 x x 0

* * x * * x
232 x 1 233 x 1 234 x x 1 235 x x 1

* * x * * x
236 x x 1 237 x x 0 238 x x x 1 239 x x x 0

* * x * * x
240 0 241 0 242 x 1 243 x 0

x * x * x x * x * x
244 x 0 245 x 0 246 x x 0 247 x x 0

x * x * x x * x * x
248 x 0 249 x 0 250 x x 1 251 x x 0

x * x * x x * x * x
252 x x 0 253 x x 0 254 x x x 0 255 x x x 0

x * x * x x * x * x
5. 7
2. Fermeture des contours

Le seuil de sélection du gradient pour la détection des contours est difficile à déterminer :
- un seuil trop élevé fait apparaître des lacunes dans les contours.
- un seuil trop faible sélectionne même des contours parasites (bruits).
En vue de la segmentation de l'image, on préfère souvent utiliser un seuil élevé, quitte à combler les lacunes
occasionnées avec un opérateur de fermeture de contours.
Différentes méthodes de fermeture locales ou globales existent.
Nous présentons ici un opérateur de fermeture séduisant par sa simplicité même s'il doit être amélioré pour donner des
résultats satisfaisants dans un plus grand éventail de configurations.
C'est un opérateur local dont le principe consiste à élaborer, dans l'image de la norme du gradient, un chemin de crête de
facteur de qualité maximum.
A partir de l'extrémité d'une lacune, le pixel voisin affecté de la norme la plus élevée du gradient est qualifié comme
point de contour.
Cette opération de fermeture élémentaire qui a lieu pour chaque extrémité de lacune s'achève dès qu'un point de contour
déjà existant est rencontré ou lorsque la longueur maximale autorisée pour la fermeture a été atteinte.
- Principe
L'image des contours est préalablement affinée.
On procède à un balayage horizontal de l'image des contours, de gauche à droite et de haut en bas.
Dès que l'on rencontre l'extrémité d'une lacune, le balayage est arrêté et laisse place à l'opération de fermeture pour
éliminer la lacune en question.
Une fois supprimée cette dernière, le balayage de l'image est repris à l'endroit où il avait été laissé.
Les points de contour se situant à l'extrémité d'une lacune, appelés points extrémités, sont identifiés comme tels s'ils
vérifient, à l'intérieur d'un voisinage 3x3, l'une ou l'autre des 2 configurations suivantes :
- avoir 1 voisin et un seul
ou - avoir exactement 2 voisins: ces derniers doivent de plus être adjacents (connexes) en 4-connexité.
Exemples de configurations extrémité: Exemple de configuration de non extrémité:
• • •
⊕ • ⊕ • •
•⊕ : points de contour
⊕ : point extrémité
Remarque : on peut détecter les points extrémités à l'aide d'une LUT.
On élabore le chemin de fermeture à partir d'un point extrémité, en explorant dans un voisinage 3x3, les 3 pixels lui
étant immédiatement voisins et les plus éloignés du contour déjà existant.
A chacun de ces 3 candidats, on affecte un poids constitué de la somme de la norme du gradient du candidat avec celle
des successeurs possibles au candidat.
On constitue ainsi pour chacun des 3 candidats, un arbre d'exploration dont on fixera la profondeur. Le candidat affecté
du poids le plus important est élu et marqué comme un nouveau point de contour.
Cette opération qui constitue une fermeture élémentaire, est réitérée pour le point de contour engendré.
La condition d'arrêt du processus est la rencontre d'un point de contour ou une l'atteinte de la longueur maximale que
l'on s'est autorisé pour le chemin de fermeture.
Pour diminuer le temps calcul, les différentes configurations d'extrémités et les candidats à examiner qui lui sont
associés sont mémorisés dans une table de look-up.
Pour ce faire, à chaque pixel de contour est associé un index V dans une table témoignant sur son voisinage 3x3. On
donne un poids, compris entre 0 et 7, à chacun de ses 8 voisins et l'index V peut être codé sur 8 bits :
5. 8
- Codage d'un point (i) dans le voisinage 3x3 d'un point de contour (*) :
3 2 1
4 * 0
5 6 7
- Calcul de l'index V dans la table LUT, pour un point de contour donné (*):
7 xi = 1 si i est point de contour
V = ∑ xi 2 i avec :
i =0 xi = 0 sinon
Configurations d'extrémité et candidats pour une fermeture élémentaire :
• • ° •
• • • ° • °
° ° ° ° ° ° ...
• : point de contour
° : point (non point de contour) candidat à une fermeture élémentaire.
Remarques
Arbre d’exploration
Plutôt que de sélectionner le prochain pixel de fermeture par comparaison du module du gradient des 3 candidats, on
peut définir pour chacun de ces 3 candidats, un arbre d’exploration de profondeur p donnée, obtenu en considérant tous
p
les candidats possibles de ce candidat (3 candidats possibles par palier), soit au total : ∑3 i =0
i
, et fournissant, pour
chacun de ces 3 candidats, un cumul de la norme des gradients. La comparaison des 3 candidats pour l’élection du point
de fermeture ne se fait pas alors simplement sur la norme du gradient des 3 candidats mais sur leur cumul respectif.
Guidage d’exploration
Si on suppose régulière la lacune à combler, on peut mémoriser les directions (dans le codage de Freeman) des points
déjà élus dans la fermeture et ainsi guider la recherche du chemin de fermeture dans la direction moyenne obtenue.
3. Suivi des contours

Le suivi de contours peut être lui-même utilisé par des opérateurs de plus haut niveau tels que :
- détection des angles
- détection des segments de droite
- ...
La condition d’arrêt du suivi est :
- soit de ne pas avoir de successeur (contour non fermé sur lui-même)
- soit de rencontrer le point de démarrage (contour fermé sur lui-même).
Afin de ne pas risquer des oscillations dans le suivi, il est nécessaire d'une part, de partir de l'image des contours
préalablement affinée (contours de largeur unitaire) et d'autre part, de marquer les points de contours déja parcourus
pour éviter de les empunter à nouveau.
(Ce marquage peut être par exemple la mise à la luminance 1 pour des points de contours noirs ( luminance 0) sur fond
blanc (255) ).
La recherche d'un point de contour successeur (x1,y1) au point de contour (x,y) lors du suivi peut être faite en
8-connexité dans le codage de Freeman, par l'utilisation de 2 tableaux DX[0..7] et DY[0..7] :
3 2 1 3 2 1 DX[0..7] = [1, 1, 0, -1, -1, -1, 0, 1]
[x-1, y-1] [x, y-1] [x+1, y-1] DY[0..7] = [0, -1, -1, -1, 0, 1, 1, 1]
Tableaux DX[0..7] et DY[0..7]
4 * 0
4 0 Pour i = 0 à 7 Faire
[x-1, y] [x, y] [x+1, y]
x1= x + DX[i]
y1= y + DY[i]
[x-1, y+1] [x, y+1] [x+1, y+1] Test de IM[x1,y1]
5 6 7 5 6 7 Fp
8-connexité et codage de Freeman Coordonnées respectives des voisins Recherche du successeur (x1,y1) de (x,y)
5. 9
1. Etiquetage des régions (≡ coloriage) (Blob colouring)

Une fois opérée la fermeture sur l'image des contours, on peut associer à la scène la liste des régions délimitées par les
contours fermés.
Ces régions vont être repérées par une étiquette caractérisée par un entier symbolisant une couleur.
L'opérateur d'étiquetage des régions va associer un même entier à tous les pixels d'une même région.
On part de l’image des contours fermés et on engendre l’image des étiquettes.
L'algorithme utilisé est séquentiel, il opère en même temps que la balayage de l'image (une seule passe est nécessaire), et
il ne nécessite que peu d'opérations par points.
Principe
L'algorithme procède en utilisant la 4-connexité comme définition de la connexité.
L'image des contours fermés est balayée horizontalement de la gauche vers la droite, du haut vers le bas.
Un masque en L inversé est déplacé sur l'image i des contours et appliqué à tous les points de cette image (contours ou
non). Il est destiné à l'attribution et la gestion des étiquettes. L'image des étiquettes est notée i' :
a a'
c b* c' b' *
Image i des contours Image i' des étiquettes
b = i[x,y] x,y: indices du point courant (*)
b = 1 : point de contour b’ = 0
Pendant le balayage de l'image, l'algorithme affecte à chaque pixel courant du masque (b’) un numéro (étiquette).
Selon le résultat de la comparaison, d'une part entre les voisins a et c dans le masque, et d'autre part entre les étiquettes
précédemment attribuées (a' et c'), le numéro (b') attribué à b est :
- soit identique à celui (c') du pixel précédemment traité (c),
- soit incrémenté (nouvelle région).
- soit égal à 0 si b = 1 (point de contour).
Du fait qu'elle est très locale, cette comparaison peut attribuer une nouvelle étiquette à un point alors qu'il appartient à
une région déjà rencontrée :
2 mêmes régions à étiquettes différentes
Durant le balayage, des numéros différents peuvent ainsi être attribués à des points appartenant cependant à la même
région.
Les numéros différents correspondant à une même région doivent alors être rendus équivalents. Pour résoudre le
problème de l'équivalence de 2 numéros, 3 structures de données sont utilisées :
- une classe d'équivalence Ck dont chaque élément e est équivalent à k et vérifie la propriété suivante :
∀ e ∈Ck, e ≡ k, k ≤ e Ck est implémenté sous la forme d’une liste linéaire chaînée
- une table d'équivalence E dont chaque élément E[e] contient le numéro de la classe d'équivalence de e :
Si E[e] = k alors e ∈Ck E[e] est implémenté sous la forme d’un vecteur (tableau 1D)
- un tableau bi-dimensionnel i' de pixels, de taille identique au tableau des pixels de contours i.
Chaque pixel de i' est étiqueté avec le numéro de sa classe d'équivalence.
Dans i', l'homologue d'un pixel de contour est étiqueté avec la valeur 0.
5. 10
Algorithme de l'étiquetage :
/* Codage de l'image initiale : 1 correspond à un point de contour ; 0 sinon */
/* Initialisation du numéro d'étiquette */

k ← 1; Ck ← {k}; E[k] ← k;
Pour chaque point (x,y) (noté b) de l'image Faire image i'

{
0
1) Si (b = 1) alors i'[x,y] ← 0; /* b est point de contour */
0
0
2) Sinon si (a' + c' = 0) (≡ (a' = 0) et (c' = 0)) /* nouvelle région pour b */
alors { i'[x,y] ← k; k ← k + 1; Ck ← {k}; E[k] ← k; }
a'
0
3) Sinon si (a' ≠ 0) et (c' = 0) /* b de la même région que a */ a' 0
alors i'[x,y] ← a';
0 c'
c' ou c'
4) Sinon si (a' = 0) et (c'≠ 0) ou (a' = c') /* b de la même région que c */ c' 0 c' 0
alors i'[x,y] ← c';
a'
c' b'
c' 0 c' a'
5) Sinon /* a' et c' sont 2 étiquettes différentes non nulles et b ≠ 1 */ a' 0 b 1
/* Gestion des équivalences de régions */ /* la plus petite de 2 étiquettes équivalentes est affectée au point courant (b’) */
{
m ← Min(a',c'); M ← Max(a',c'); p ← E[m]; q ← E[M];
Si (q = M) alors { Cp ← Cp ∪ {M}; E[M] ← p; i'[x,y] ← p; } /* on affecte l’étiquette la plus petite aux
étiquettes d’une même région */
Sinon si (q > p) alors { ∀ z ∈Cq Faire E[z] ← p; Cp ← Cp ∪ Cq; i'[x,y] ← p; } /* on réaffecte les étiquettes
précédentes équivalentes avec la nouvelle étiquette équivalente plus petite */
Sinon si (p = m) alors { Cq ← Cq ∪ {m}; E[m] ← q; i'[x,y] ← q; } /* on affecte l’étiquette la plus petite
aux étiquettes d’une même région */
Sinon { ∀ z ∈Cp Faire E[z] ← q; Cq ← Cq ∪ Cp; i'[x,y] ← q; } /* on réaffecte les étiquettes précédentes
équivalentes avec la nouvelle étiquette équivalente plus petite */
}
}
5. 11
/* On considère que l'étiquetage est réalisé après cette 1ère passe de l'image, l'image i' contenant les informations
intrinsèques.
Néanmoins, pour affecter une même étiquette aux éléments d'une classe donnée (≡ à tous les numéros représentant une
même région), il est nécessaire de réaliser une seconde passe (balayage de i') pour remplacer l'étiquette d'un pixel par
celle de sa classe d'équivalence : */
Pour tout point (x,y) de l'image i' Faire i'[x,y] ← E[i'[x,y]]
Exemple de Résultat de l'opérateur d'étiquetage : (0 d'initialisation ↓ -effet de bord-)
0 0 0 0 0 0 0 0
0 1 1 1 0 2 2 0 3
0 1 1 0 4 2 0 5 3
0 1 0 6 2 0 7 3 3
0 1 1 1 0 8 3 3 0
0 0 0 0 9 3 0 0 10
0 11 11 11 0 3 3 3 3
0 11 11 0 12 3 3 3 3
0 11 11 11 3 3 3 3 3
Image initiale des contours i Image des étiquettes i' (après 1 seule passe)
Table E et classes C des équivalences associées :
index k E C
1 1 →1 →2 →4 →6
2 (2→)1 →2 →4 →6
3 3 →3 →5 →7 →8 →9 → 10 → 12 → 11
4 (4→2→) 1 →4
m=2 M=4 p=2 q=4 5 (5→) 3 →5
m=3 p=3 6 (6→2→) 1 →6
M=10 q=10 7 (7→) 3 →7
8 (8→) 3 →8
9 (9→) 3 →9
10 (10→) 3 →10
m=11 p=11 11 (11→) 3 →11
M=12 q=3 12 (12→) 3
Les classes d'équivalence à retenir sont celles pour lesquelles : E[k] = k , à savoir les 2 régions d’étiquette 1 et 3.
5. 12
2. Approximation polygonale des contours

But : - réduire encore la quantité d’informations pour ne garder que que le nécessaire pour compréhension.
- structurer les informations.
Une fois effectué l'étiquetage des régions, une technique courante consiste à approcher le périmètre de chaque région
par un polygone, afin toujours de réduire la quantité d'informations présentes dans l'image aux seules informations utiles,
et donner une représentation de l'image utilisable par une métode de Reconnaissance Des Formes.
Il est clair que l'on restera d'autant plus fidèle à la forme de la région que le nombre s de sommets (≡ nombre de côtés)
du polygone sera proche du nombre p de pixels du périmètre de la région, mais une valeur de s faible suffit
généralement pour sa compréhension.
Principe
Différentes méthodes existent pour effectuer l'approximation polygonale d'un contour :
- l'algorithme de Ramer (dite « méthode de la corde »), détermine le point de l'arc de contour à approximer situé à la
plus grande distance (d1) du segment reliant les extrémités de l'arc. Ce processus est réitéré à partir de ce point tant que
la distance (di pour l'étape i) est supérieure à un certain seuil :
C C
d2 d3
d1 B B
A A
Contour AB Approximation polygonale dans le cas :
d1 > seuil ; d2 < seuil; d3 < seuil.
On peut évaluer une distance euclidienne : d ( M 1 − M 2 ) = ( x 2 − x1 ) 2 + ( y 2 − y1 ) 2 ou, pour réduire le temps

calcul, une pseudo-distance : d ( M 1 − M 2 ) = x 2 − x1 + y 2 − y1
Inconvénient : comportement lié à la taille du contour :
On peut corriger ce problème en normalisant la distance par rapport à la longueur du contour.
- l'algorithme de division et extension décrit par Pavlidis procède d'une façon similaire, mais la condition d'arrêt porte
non plus sur la distance, mais sur l'aire séparant l'arc de contour au segment qui l'approxime :
Le point C divise l'aire 'AB' en 2 parties égales.

A
5. 13
- un autre algorithme proposé par Slansky, est non itératif et effectue un suivi du contour à approximer :
à chaque pas élémentaire du suivi, on évalue la distance entre l'arc de contour parcouru et le segment reliant le point de
départ au point courant du suivi. Le dernier segment tracé avant dépassement de cette distance par rapport au seuil
constitue l'approximation polygonale de l'arc :
C Le point C de l'arc est uniquement fonction du "passé"

défini par le suivi à partir du point A,
et non de l'ensemble de l'arc AB.
B
Application aux contours fermés
L'image précédemment segmentée est telle qu'elle présente des contours fermés, et il se pose alors le problème du choix
des points de démarrage pour effectuer l'approximation du périmètre d'une région.
2 cas de figure peuvent se présenter :
- le périmètre de la région en question (R1) possède une partie commune, que nous appelerons frontière, avec celui d'une
autre région (R2) . Si l'on désire représenter cette dernière frontière par la même ligne polygonale pour les 2 régions
concernées, cela impose que les extrémités de la frontière commune soient des sommets de la ligne polygonale.
On effectuera donc l'approximation polygonale du périmètre de la région en approximant d'une part la frontière
commune, et d'autre part le reste du périmètre de la région :
région région
R1 R2
- la région en question (R1) est entièrement incluse dans une autre région (R2) ou constitue le cadre même de l'image.
On peut par exemple démarrer l'approximation entre les 2 points du périmètre les plus éloignés, qui sont à priori des
candidats pour être des sommets. Mais une consommation importante en temps calcul pour des résultats non garantis ont
fait que, quitte à effectuer des corrections ultérieures, il est préférable de simplement démarrer entre 2 points contigus A
et B pour uniquement calculer le point C situé à la distance maximum du mini segment [AB], et ensuite faire
l'approximation de l'arc AC d'une part, et de l'arc CA d'autre part :
AB
région R 2
région R
1
5. 14
Après les phases de : - Détection des contours

- Fermeture des contours
- Etiquetage des régions
- Approximation polygonale du périmètre des régions
on dispose d'une représentation des donnée simplifiée de l'image brute, susceptible d'être utilisée par une méthode de
reconnaissance :
- Les régions de l'image constituent les noeuds d'un graphe.
- Les arcs du graphe témoignent des adjacences entre les régions.
- A un noeud on peut déterminer et attribuer un certain nombre d'attributs sur la région :
• liste (et nombre) des sommets du polygone approximant le périmètre de la région.
• forme géométrique de la région.
• niveau de gris moyen de la région.
• centre de gravité de la région.
• ...
1
3
2
3
4 1
2 4
5
6
52 6
Image étiquetée Graphe des régions associé
Des règles géométriques simples permettent alors d'élaborer des décisions quant à la forme d'objets dans l'image par
exemple.
3. Transformation de Hough (TH)

Plutôt que d'approximer les contours par des segments de droite, une autre approche, duale de la première, consiste à
détecter dans une image de contours les points appartenant à des segments de droite.
Une application possible est par exemple la détection de routes ou bâtiments (structures rectilignes) dans une image
aérienne de campagne.
Introduction
Intéressante par son analyse globale de l'image, cette méthode de détection des segments de droite agit sur une image
dont on a préalablement extrait les contours.
On applique la transformation à chaque point de contour, se plaçant ainsi dans un espace dual, appelé espace des
paramètres.
Seuls les points colinéaires sont retenus par une technique d'accumulation d'hypothèses.
5. 15
Les bases de la transformation
La méthode d'origine (TH0) :
Hough introduit en 1962 un espace de paramètres dans lequel la droite d'équation : y = a 0 x + b 0 est représentée
par le couple (a0, b0) :
Y Plan image b Espace des paramètres
y = a0 x + b0 b0
X a
a0
La TH 0 d'une droite est un point
Ainsi, dans cet espace, l'ensemble des droites coucourantes en (x0, y0) a pour représentation la droite d'équation :
b = x0 a + y0 :
Y b
y
0
b = -x 0 .a + y0
X a
x0
"La TH d'un point est une droite"
0
On voit donc que dans cet espace dual, on a un moyen simple de caractériser des points alignés.
En effet, soit une ensemble de points (xi, yi) tous appartenant à la droite d'équation :
y = a 0 x + b 0 . A chacun de ces points, on associe l'ensemble des droites concourantes en ce point, que l'on représente
dans l'espace des paramètres. On obtient un faisceau de droites concourantes en (a0, b0) :
X
Y b
b0
X a
a0
La TH 0 d'un ensemble de points alignés est un point
(= point de concours des droites issues des TH des points alignés)
0
5. 16
La paramétrisation polaire (TH) :
La représentation de la droite : y = ax + b par le couple de paramètres (a, b) entraîne que, pour examiner toutes les
directions de droite, les valeurs de a et b ne doivent pas être bornées, ce qui est impropre à une formulation informatique
de cette paramétrisation.
C'est pourquoi Duda et Hart ont proposé une paramétrisation polaire des droites par leur distance ρ à l'origine et la
direction θ de leur normale :
ρ
θ
X
En coordonnées polaires, une droite a pour équation : ρ = x.cos θ + y.sin θ
Propriétés :
- un point (x0, y0) de l'espace cartésien (X, Y) a pour transformée une courbe sinusoïdale d'équation :
ρ = x0.cos θ + y0.sin θ dans l'espace des paramètres :
ρ
Y
ΤΗ
y0 0 θ
−π π
X
x0
La TH d'un point est une sinusoïde
- un point (ρ0, θ0) de l'espace des paramètres est transformé en une droite d'équation :
ρ0 = x.cos θ0 + y. sin θ0 dans l'espace (X, Y) :
Y ρ
−1
ΤΗ
ρ
ρ0 0
θ0
X θ
θ0
La TH d'une droite est un point
5. 17
- Des points colinéaires dans l'espace (X, Y) sont transformés en sinusoïdes passant par un même point :
Y
1 ρ
A 1
ΤΗ
0,5 B A
ρ0
ρ0
θ0 C
0 −π π
1 X θ
0,5 0 θ
0 B
C
-1
La TH d'un ensemble de points alignés est un point

(= point de concours des sinusoïdes issues des TH des points alignés)
- des points situés sur une même courbe dans l'espace des paramètres correspondant à un faisceau de droites dans
l'espace (X,Y).
La mise en oeuvre
Le processus :
L'ensemble des droites de paramètres (ρ, θ) passant par un point (x ,y) de l'image a pour équation :
ρ = x. cos θ + y. sin θ.
Ceci suggère d'échantillonner le paramètre angulaire θ en valeurs θi avec un pas d'échantillonnage ∆θ.
Pour chaque point de contour (x, y) de l'image, on calcule pour tous les échantillons θi , sa transformée :
(ρ = x. cos θi + y. sin θ i que l'on quantifie en classes :
∆
ρi = [ρi , ρ i+1] de largeur ∆ρ.
On construit donc un tableau bidimensionnel, consitué de cases de dimensions ∆ρ et ∆θ, que l'on incrémente afin de
comptabiliser les intersections des transformées des points de l'image, intersections qui, on l'a vu, rendent compte de la
présence de points colinéaires.
Chaque case (ρi, θi ) du tableau est alors représentative d'un ensemble de points alignés dans une direction
perpendiculaire à θi , et dont la droite moyenne est repérée à une distance ρi à l'origine.
En fin de traitement, aux éléments du tableau ayant une valeur supérieure à un seuil que l'on se fixe en fonction de
l'image, correspondent des ensembles de points appartenant effectivement à des segments de droite.
Le processus peut donc être interprété comme une élection où chaque point (xi , yi ) « vote » pour les droites qui le
contiennent.
La droite réalisant le meilleur score est la droite d'alignement de ces points (s'ils sont bien alignés).
5. 18
Exemple pour 5 points sommairement alignés
Image initiale de contours
Y (pixels)
40 (1)
35 (2)
30
25
20
15 (3)
10 ρ (4)
5 θ (5)
X (pixels)
0 5 10 15 20 25 30 35 40
Transformation : Discrétisation utilisée : En θ : ∆θ = 20° En ρ : ∆ρ = 10 pixels
ρ
(pixels)
40
30
20
10
0 (1) θ (degrès)
0 20 40 60 80 100 120 140 160 180
-10 (2)
(3)
-20
(4)
-30
-40 (5)
Tableau de Hough
θ (degrès)
ρ 0 20 40 60 80 100 120 140 160 180
(pixels)
40
1 1 1 1 1 1 0 0 0
30
2 4 5 3 2 2 1 0 0
20
2 2 0 2 2 2 1 1 1
10
2 0 0 1 2 2 2 1 1
0 (1)
0 0 0 0 1 2 2 2 2
-10 (2)
0 0 0 0 0 1 1 2 1 (3)
-20
0 0 0 0 0 0 1 1 1 (4)
-30
0 0 0 0 0 0 1 1 1
-40 (5)
Avec un seuil égal à 5, on détecte un unique segment, formé de 5 points colinéaires, dont la perpendiculaire a une
direction θ comprise entre 40° et 60°, et distant de 20 à 30 pixels de l'origine.
5. 19
Filtrage adapté
La transformée de Hough peut être considérée comme une convolution de l'image binaire des points de contour par un
filtre rectiligne dont la réponse est égale au nombre de points ayant une « image » (ρi, θi ) donnée.
La convolution par le gabarit de la forme recherchée constitue, notons-le, le filtrage ayant le meilleur rapport signal sur
bruit.
Ceci signifie que les méthodes basées sur la transformation de Hough sont par nature peu sensibles au bruit, ce qui n'est
pas forcément le cas des méthodes de détection locale (suivi de contour...)
Transformation de Hough comme collection d'histogrammes

Si on restreint le traitement à une direction de droites données, le tableau d'accumulateurs construit peut être considéré
comme un histogramme de données en ρ.
De même, si l'on ne recherche que les segments situés à une distance ρ de l'origine, le tableau apparaît alors comme un
histogramme en θ.
La transformation de Hough peut donc être interprétée comme une collection d'histogramme. En particulier, on aura
intérêt à affectuer la recherche des maximums du tableau, ou mieux, des maximums locaux, et à utiliser les algorithmes
de regroupement par pics mis au point pour l'analyse d'histogramme multidimensionnels.
Ajustement des réglages

3 « réglages » de la transformation sont laissés libres à l'utilisateur :
- la pas de quantification ∆ρ
- le pas d'échantillonnage ∆θ
- la valeur du seuil à appliquer au tableau, en-dessous de laquelle on ne retient pas une liste de points associés
à une case du tableau comme points colinéaires.
Des inconvénients intrinsèques à la méthode demeurent :

En effet, agissant sur le nombre de points alignés, le seuil choisira une liste nombreuse de points à peu près ou même
accidentellement colinéaires, plutôt qu'une petite liste de points parfaitement alignés.
Ceci est à rapprocher du fait que des points alignés avec un segment de droite détecté sont inévitablement selectionnés.
Enfin, on peut remarquer que la valeur du seuil devra être d'autant plus faible que la discrétisation en ∆ρ et ∆θ sera plus
fine, en raison de la dispersion des segments dans des cases différentes du tableau.
Eléments de solutions aux inconvénients :

Pour pallier à ces problèmes on peut :
- recalculer successivement la transformée en supprimant à chaque étape les points appartenant aux grands segments.
- ne pas examiner les valeurs du tableau case par case, mais partitionner l'espace des paramètres en regroupant les
valeurs sitèes autour d'un pic (calcul du maximum local du tableau d'accumulateurs.
Intervalles de variation de ρ et θ :
L'origine 0 du paramètre ρ peut être choisie arbitrairement, mais une origine placée au centre de l'image limiterait
l’influence de la discrétisation de θ sur le calcul de ρ , diminuant ainsi l'erreur sur celui-ci.
Si Nx et Ny désignent les dimensions de l'image, la valeur maximale de ρ est donc (origine au coin haut gauche de l’image) :
2 2
 Nx   Ny 
ρ max =   + 
ρ max = Nx + Ny 2 2
Avec une origine au centre de l’image :  2   2 
+
O
ρ max
Ny Ny +
ρ max O
Nx Nx
5. 20
Les intervalles de variation de ρ et θ sont étroitement liés : on peut choisir de faire varier l'angle θ sur un intervalle de
largeur 2π, et ne retenir les positions ρ qu'entre 0 et ρmax, ρ correspondant ainsi à une distance.
Ce choix qui découle le plus immédiatement de la théorie n'est pas le seul possible : pour réduire le temps de calcul , on
peut se limiter à faire varier θ sur un intervalle de largeur π, et balayer ρ entre - ρmax et + ρmax. Les directions θ
« manquantes » étant tout de même examinées en considérant des valeurs de ρ négatives :
 π π
 −π < θ < +π − < θ < +
 ou :  2 2
0 < ρ < ρ max − ρ max < ρ < + ρ max
ρ homogène à une distance à l’origine
Y
ρ
1 A 1
A
0.5 B ρ0
ρ0
θ
0 0 C θ0− π
X 0
0.5 1 +π θ
−π θ0
B
(−ρ ) C
0
−1
Pour implémenter la transformée, on peut donc choisir de prendre l'origine 0 au centre de l'image, de faire varier θ dans
l'intervalle [ -π/2, +π/2 ] et de balayer ρ de - ρmax à +ρmax .
avec : ρ max = Nx 2 + Ny 2
Le nombre de calculs
Le calcul de la transformée discrète consiste pour chaque point et pour chaque direction θ à incrémenter un
accumulateur. Le nombre de calculs est donc proportionnel au nombre N de points de contour de l'image et au nombre
de directions θi examinées.
Avec un environnement logiciel dans lequel la mémorisation des points associés à chaque case du tableau n'est pas
envisageable (une mémoire imporante est nécessaire pour mémoriser la case du tableau d'accumulateurs pour laquelle
chaque point de contour a voté), il est préférable de procéder à une 2ème passe de traitement, dans laquelle chaque case
du tableau est examinée et non plus constituée comme au cours de la 1ère passe. Le nombre de calculs est donc doublé.
Extensions
La transformation de Hough est un outil puissant de Reconnaissance Des Formes. Elle peut être généralisée à la
détection de cercles, d'ellipses ...
En effet, pour les cercles par exemple, l'examen de l'équation d'un cercle de centre (a,b) et de rayon r :
r 2 = ( x − a ) 2 + ( y − b) 2
permet de voir immédiatement qu'il est possible d'étendre la méthode de Hough à un espace de 3 paramètres (a,b,r).
Duda et Hart ainsi que Ballard font remarquer que la transformation de Hough peut être étendue à n'importe quelle
courbe paramétrée :
5. 21
- Pour les lignes : (rappel)

Point de contour Transformation Paramètres : (ρ,θ)
(x, y) → ρ = x.cos θ + y.sin θ
ρ
ρ
θ
X θ
0
- Pour les cercles :

Point de contour Transformation Paramètres : (a,b,r)
(x, y) → r2 = (x - a)2 + (y - b)
b a
r
X
0 b
a
- Pour les ellipses :

Point de contour Transformation Paramètres : (a, b, rx, ry, θ)
(x, y) → 1 = (x - a)2/rx2 + (y - b)2/ry2 hypercube de dimensions :
plus rotation de θ a, b, rx, ry, θ
Algorithme de la détection des segments de droite par la Transformation de Hough :

(Version à 2 passes) (L'image initiale IM de contours a la taille Nx*Ny)
/* Initialisation */
- Choix de la discrétisation en ρ et en θ : ∆ρ et ∆θ.
- Choix du seuil de sélection d'un pixel comme appartenant à un segment de droite.
- Mise à 0 du Tableau d'accumulateur de Hough : Accu[r ,θ] avec:
− ρ max < r < + ρ max par pas de : ∆ρ; ρ max = Nx 2 + Ny 2
-π/2 < θ < +π/2 par pas de : ∆θ.
/* 1ère passe : construction du tableau de Hough */

Pour tout point (x,y) de l'image de contours IM Faire /* balayage de l'image des contours */
{
Si le point IM[x,y] est un point de contour Faire
{
Pour θ de -π/2 à +π/2 par pas de ∆θ Faire
{
ρ = x. cos θ + y. sin θ
Calcul de: r = arrondi de ρ avec l'erreur de quantification ∆ρ
Accu[r ,θ] = Accu[r ,θ] + 1
}
}
5. 22
/* 2ème passe : examen du tableau de Hough

et qualification d'un point de contour ∈ à un segment de droite (case Accu[r,θ] de valeur élevée) */
Pour tout point (x,y) de l'image de contours IM Faire /* balayage de l'image */

{
Si le point IM[x,y] est un point de contour Faire
{
Keep = Faux
/* Rebalayage du Tableau de Hough
(la mémorisation de cette information aurait pu être faite durant la constitution du tableau, évitant
ainsi ce rebalayage, mais au prix d’un coût très élevé en mémoire)
Pour θ de -π/2 à +π/2 par pas de ∆θ Faire
{
ρ = x. cos θ + y. sin θ
Calcul de: r = arrondi de ρ avec l'erreur de quantification ∆ρ
Si Accu[r ,θ] ≥ seuil alors Keep = Vrai
}
Si Keep alors ne rien faire /* IM[x,y] est conservé */
Sinon IM[x,y] est supprimé.
}
(Après traitement, l'image IM ne contient plus que les points de contours∈ à un segment de droite ).
Résultats de la Transformation de Hough (TH) sur une image test (taille 90x90) :
Image test (taille 90x90) : Image après détection des segments de droite par TH :
Discrétisation utilisée :
En θ : ∆θ = 5°
En ρ : ∆ρ = 2 pixels
Seuil du tableau de Hough : Seuil = 30
Le seuil est homogène à un nombre de pixels égal à la longueur minimale de segment de droite à détecter.
5. 23
5 ANNEXE. Opérateurs sur Images de Contours

Algorithme de Chin & Wan (variante : extrait les bords des contours !)
1) Eliminer chaque point de contour de l'image qui est au centre de l’une au moins des 8 configurations Ci (i = 1 à 8) en
voisinage (3x3) suivantes (idem étape 1 de l’algorithme initial de Chin & Wan) :
0 0 0 0 1 x x 1 x  x 1 0
1 1* 1  0 1* 1  1 1* 1  1 1* 0
    
 x 1 x  0 1 x  0 0 0   x 1 0
Sud Est Nord Ouest
x 0 0 0 0 x x 1 x x 1 x
1 1* 0  0 1* 1  0 1* 1  1 1* 0 
   
 x 1 x   x 1 x  0 0 x   x 0 0 
SO SE NE NO
x : sans importance.
1 : point de contour. 0 : non point de contour.
* : point central d'application du masque.
2) Mais ne pas toucher à ce point de contour s’il coïncide avec l’une au moins des 4 configurations Di
(i =1 à 4) (1x3) et (3x1) suivantes :
0 1
[0 1*
1] [1 1*
0 ] 1* 
 
1* 
 
 1   0 
3) Si le point de contour ne satisfait à aucune des configurations des étapes 1 et 2 du présent algorithme, éliminer ce
point de contour.
__________
5. 24
Traitement d'Images TP 5. Opérateurs sur contours
TP 5. Opérateurs sur images de contours
1. Affinage des contours ALGORITHME DE CHIN & WAN
Lecture N&B :
Nx = 75 Ny = 120
Contours : J := Moyenne( I) K := NormeGradient4Diff ( J) L := Binarisation ( K , 13)
M := ChinWan( L) N := ChinWan( M )
Affinage des contours :
Image brute Image des contours Contours affinés (1 fois) Contours affinés (2 fois)
I L M N
2. Détection des contours DETECTEUR DE CONTOURS DE DERICHE
Lecture N&B :
Nx = 75 Ny = 120
Contours : α := 1 O := DericheNormeGrad( I , α ) P := Binarisation ( O, ) Q := DericheDirGrad( I , α )
Image brute Image norme du gradient Image des contours
I O P
TP 5. 1
1. Coloriage ETIQUETAGE DES REGIONS
Lecture N&B :
I := READ_IMAGE( "regions.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 20 Ny = 20
Etiquetage J := Etiquetage ( I)
Visualisation des étiquettes : K := RecadrageDyn( J)
Image des contours fermés Image des étiquettes
2. Transformation de Hough TRANSFORMATION DE HOUGH
Lecture N&B :
I := READ_IMAGE( "Hough.bmp" ) Nombre de colonnes : Nx := cols( I) Nombre de lignes : Ny := rows( I)
Nx = 210 Ny = 228
Inversion video : J := InvVideo( I)

Transformation de Hough : K := Hough( J)
Image des contours Image inverse video Image après Transfo. de Hough
I J
K
TP 5. 2

H ←0 for i ∈ 0 .. 255
n
for y ∈ 0 .. rows( I) − 1 i
for x ∈ 0 .. cols( I) − 1 for i ∈ 255 , 254 .. 0
y, x i
H ←H +1 255
n n ∆←
maxi − mini
H
for y ∈ 0 .. rows( I) − 1
255
RecadrageDyn%( I , nb , nh) ≡ ∆← for x ∈ 0 .. cols( I) − 1
nh − nb
( y , x )
for y ∈ 0 .. rows( I) − 1 J ← round  I − mini ⋅ ∆
y, x 
for x ∈ 0 .. cols( I) − 1 J
( y , x )
J ← round  I − nb ⋅ ∆
y, x  InvVideo( I) ≡ for y ∈ 0 .. rows( I) − 1
J for x ∈ 0 .. cols( I) − 1
J ← 255 − I
Convol3x3( I , Mask3x3) ≡ for y ∈ 1 .. rows( I) − 2 y, x y, x
for x ∈ 1 .. cols( I) − 2 J
som ← 0
for i ∈ 0 .. 2
for j ∈ 0 .. 2
som ← 255 if som > 255
J ← som
y, x
J

for x ∈ 1 .. cols( I) − 2
som ← 0
for i ∈ 0 .. 2
for j ∈ 0 .. 2
y+i− 1 , x+ j− 1 i, j
som ← som
som ← 255 if som > 255
J ← som
y, x
J
TP 5. 3

y, x y, x y, x y, x
y, x
J
g ←f 〈x〉
n n f ←I
g 〈x〉
return J
for x ∈ 1 .. cols( I) − 2
for j ∈ 0 .. 2 0 if y = 0 1 if y = 1
3⋅ i+ j y+i− 1 , x+ j− 1
vtri ← sort ( v)
J ← vtri
y, x 4
J 1 1 1
9 9 9
 
Moyenne( I) ≡ M ← 
1 1 1
9 9 9
1 1 1
 
9 9 9
J ← Convol3x3( I , M )
J
Dilatation( I) ≡ for y ∈ 1 .. rows( I) − 2 DilatationGris ( I) ≡ for y ∈ 1 .. rows( I) − 2

for i ∈ 0 .. 2 for i ∈ 0 .. 2
for j ∈ 0 .. 2 for j ∈ 0 .. 2
I v ←I
y+ i−1 , x+ j−1 3⋅ i+ j y+ i− 1 , x+ j− 1
v ←
3⋅ i+ j 255 J ← max( v)
y, x
Test ← v
0 J
for i ∈ 1 .. 8
Test ← v ∨ Test if i ≠ 4
i
J ← 255 if Test = 1
y, x
J ←I otherwise
y, x y, x
J
TP 5. 4
Erosion ( I) ≡ for y ∈ 1 .. rows( I) − 2 ErosionGris( I) ≡ for y ∈ 1 .. rows( I) − 2

for i ∈ 0 .. 2 for i ∈ 0 .. 2
for j ∈ 0 .. 2 for j ∈ 0 .. 2
I v ←I
y+ i− 1 , x+ j− 1 3⋅ i+ j y+ i− 1 , x+ j− 1
v ←
3⋅ i+ j 255 J ← min( v)
y, x
Test ← v
0 J
for i ∈ 1 .. 8
Test ← v ∧ Test if i ≠ 4
i
J ←I if Test = 1
y, x y, x
J ← 0 otherwise
y, x
J
NormeGradient4Diff ( I) ≡ for y ∈ 1 .. rows( I) − 2 Ampli( I , gain) ≡ for y ∈ 0 .. rows( I) − 1
d ←I −I r←I ⋅ gain
0 y, x y , x− 1 y, x
d ←I −I J ←r
1 y− 1 , x y , x− 1 y, x
d ←I −I J ← 255 if r > 255
2 y− 1 , x y, x y, x
d ←I −I J ← 0 if r < 0
3 y− 1 , x−1 y, x y, x
for i ∈ 0 .. 3 J
D ← d
i i
NormeGradient ← max( D)
y, x
NormeGradient
IndiceMax( v) ≡ N ← length ( v)
DirGradient4Diff ( I) ≡ for y ∈ 1 .. rows( I) − 2 IndiceMax ← 0
for x ∈ 1 .. cols( I) − 2 Max ← v
0
d ←I −I
0 y, x y , x− 1 for i ∈ 1 .. N − 1
d ←I −I if v > Max
1 y− 1 , x y , x− 1
i
d ←I −I Max ← v
2 y− 1 , x y, x
i
d ←I −I IndiceMax ← i
3 y− 1 , x− 1 y, x
for i ∈ 0 .. 3 IndiceMax
D ← d
i i
imax ← IndiceMax( D)
DirGradient ← imax if d ≥0
y, x imax
DirGradient ← imax + 4 otherwise
y, x
DirGradient
TP 5. 5
Codage RVB de la Direction du Gradient :

Noir (RVB=0,0,0) Blanc (RVB=255,255,255) Gris (RVB=127,127,127)
Rouge (RVB=255,0,0) Magenta (RVB=255,0,255) Marron(127,0,0)
Vert (RVB=0,255,0) Kaki (RVB=127,127,0)
Bleu (RVB=0,0,255) Cyan (RVB=0,255,255) Violet (RVB=127,0,127)
Jaune (RVB=255,255,0) Orange (RVB=255,127,0)
Rvb ( I) ≡ for y ∈ 0 .. rows( I) − 1 rVb( I) ≡ for y ∈ 0 .. rows( I) − 1 rvB( I) ≡ for y ∈ 0 .. rows( I) − 1

for x ∈ 0 .. cols( I) − 1 for x ∈ 0 .. cols( I) − 1 for x ∈ 0 .. cols( I) − 1
R ← 255 if I =0 V ← 0 if I =0 B ← 0 if I =0
R ← 0 if I =1 V ← 255 if I =1 B ← 0 if I =1
R ← 0 if I =2 V ← 0 if I =2 B ← 255 if I =2
R ← 255 if I =3 V ← 127 if I =3 B ← 0 if I =3
R ← 255 if I =4 V ← 0 if I =4 B ← 255 if I =4
R ← 127 if I =5 V ← 127 if I =5 B ← 0 if I =5
R ← 0 if I =6 V ← 255 if I =6 B ← 255 if I =6
R ← 255 if I =7 V ← 255 if I =7 B ← 0 if I =7
R V B
T T
∆x ≡ ( 1 1 0 −1 −1 −1 0 1 ) ∆y ≡ ( 0 −1 −1 −1 0 1 1 1 )
SuppressionNonMaximaLocaux( M , D) ≡ for y ∈ 1 .. rows( M ) − 2

for x ∈ 1 .. cols( M ) − 2
i←D
y, x
j ← mod( i + 4 , 8 )
M ← 0 if M ≤M
y, x y, x y+ ∆yi , x+ ∆xi
M ← 0 if M ≤M
y, x y, x y+ ∆y j , x+ ∆x j
M
TP 5. 6
0 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 0
0 0 0 1 1
 0 0 1 1 0
 0 1 1 0 0
 1 1 0 0 0

       
D ≡ 0 0 1 1 1 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 1 1 1 0 0
1 2 3 4
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
       
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0

       
D ≡ 1 1 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 1 1
5 6 7 8
1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1
       
1 0 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 1

 for x ∈ 2 .. cols( I) − 3 
 
 SDG ← 0 
 SG ← 0 
 
for k ∈ 1 .. 8
 
 S←0 
 for j ∈ 0 .. 4 
 
 for i ∈ 0 .. 4 
 S ← S + I ⋅(D )  
  y+ j−2 , x+i−2 k j , i 
 S 
 S← 
6
 
 S2 ← 0 
 for j ∈ 0 .. 4 
 
 for i ∈ 0 .. 4 
 
y+ j− 2 , x+ i−2 ( k) j , i
2
S2 ← S2 +  I ⋅ D
   
 
 S2 ←
S2 
 6 
 D←S−I 
 y, x 
 1 
 
( )
2
 G ← S2 − S
2 
 
 SG ← SG + G 
 
SDG
 J ←I − 
y, x y, x
 SG 
 J ← 0 if J <0 
y, x y, x
 
 J
y, x
← 255 if J
y, x
> 255 
 
 J 
TP 5. 7
 
0 0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 0 0
0 0 0 1 1
 0 0 1 1 0
 0 1 1 0 0
 1 1 0 0 0

       
D ≡ 0 0 1 1 1 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 1 1 1 0 0
1 2 3 4
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
       
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0
 0 0 0 0 0

       
D ≡ 1 1 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 0 0 D ≡ 0 0 1 1 1
5 6 7 8
1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1
       
1 0 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 1

 
 for x ∈ 2 .. cols( I) − 3 
 SDG ← 0 
 SG ← 0 
 
 for k ∈ 1 .. 8 
 S←0 
 for j ∈ 0 .. 4

 
 for i ∈ 0 .. 4 
y+ j−2 , x+ i− 2 ( k) j , i
 S ← S + I ⋅ D 
   
 S 
 S← 
 6 
 2 
S
 S2 ← 
 6 
 D←S−I 
y, x
 
 1 
 
( )
2
 G ← S2 − S
2 
 
 
 SG ← SG + G 
 SDG 
 J
y, x
←I
y, x
− 
SG
 
 J
y, x
← 0 if J
y, x
<0 
 
 J ← 255 if J > 255 
y, x y, x
 
 J 
TP 5. 8

for x ∈ 2 .. cols( I) − 3
for j ∈ 0 .. 2
for i ∈ 0 .. 2
for m ∈ 0 .. 2
for k ∈ 0 .. 2
Tmp ←I
m⋅ 3+ k y+ j+ m− 2 , x+ i+ k− 2
3⋅ j+ i
Moy ← 0 otherwise
3⋅ j+ i
3⋅ j+i
3⋅ j+i
Mini ← min( Var)
for i ∈ 0 .. 8
y− 2 , x− 2 i i
W
ChinWan( I) ≡ for y ∈ 2 .. rows( I) − 3

for x ∈ 2 .. cols( I) − 3
TP 5. 9
 
( 1 − e− α )
2
 
DericheNormeGrad( I , α ) ≡ K←
 −α − 2⋅ α 
 1 + 2⋅ α ⋅ e −e 
 
( 1−e )
2
−α
 
 S←− 
−α
 e 
 −α 
 a ← S⋅ e 
 −α 
 b1 ← −2 ⋅ e 
 b2 ← e
− 2⋅ α 
 
 a0 ← K 
 −α 
 a1 ← K⋅ ( α − 1 ) ⋅ e 
 a2 ← a1 − K⋅ b1 
 
a3 ← −K⋅ b2
 
 for y ∈ 0 .. rows( I) − 1 
 for x ∈ 1 .. cols( I) − 1 
 
 Sp ← a⋅ I if x = 1 
y, x y , x− 1
 Sp ← a⋅ I − b1⋅ Sp if x = 2

 y, x y , x− 1 y , x− 1 
 Sp ← a⋅ I − b1⋅ Sp − b2⋅ Sp if x > 2 
 y, x y , x− 1 y , x− 1 y , x− 2 
 for y ∈ 0 .. rows( I) − 1 
 for x ∈ cols( I) − 2 , cols( I) − 3 .. 0

 
 Sm ← a⋅ I if x = cols( I) − 2 
y, x y , x+ 1
 
 Sm ← a⋅ I − b1⋅ Sm if x = cols( I) − 3 
y, x y , x+ 1 y , x+ 1
 Sm ← a⋅ I − b1⋅ Sm − b2⋅ Sm if x < cols( I) − 3

 y, x y , x+ 1 y , x+ 1 y , x+ 2 
 for y ∈ 0 .. rows( I) − 1 
 
 for x ∈ 1 .. cols( I) − 2 
 S
y, x
← Sm
y, x
+ Sp
y, x

 
 for y ∈ 0 .. rows( I) − 1 
 for x ∈ 1 .. cols( I) − 2 
 
Gp ← a0⋅ S if y = 0
 y, x y, x 
 Gp ← a0⋅ S + a1⋅ S − b1⋅ Gp if y = 1 
 y, x y, x y− 1 , x y− 1 , x 
 Gp ← a0⋅ S + a1⋅ S − b1⋅ Gp − b2⋅ Gp if y ≥ 2 
y, x y, x y− 1 , x y− 1 , x y− 2 , x
 
 for y ∈ rows( I) − 2 , rows( I) − 3 .. 0 
 for x ∈ 1 .. cols( I) − 2 
 
 Gm ← a2⋅ S if y = rows( I) − 2 
y, x y+ 1 , x
 
Gm ← a2⋅ S − b1⋅ Gm if y = rows( I) − 3
 y, x y+ 1 , x y+ 1 , x 
 
TP 5. 10
 Gm ← a2⋅ S + a3⋅ Sm − b1⋅ Gm − b2⋅ Gm if y < rows( I) − 3 

 y, x y+ 1 , x y+ 2 , x y+ 1 , x y+ 2 , x 
 for y ∈ 0 .. rows( I) − 2 
 
for x ∈ 1 .. cols( I) − 2
 
 Gx
y, x
← Gm
y, x
+ Gp
y, x 
 
 for y ∈ 1 .. rows( I) − 1 
 for x ∈ 0 .. cols( I) − 1 
 
Sp ← a⋅ I if y = 1
 y, x y− 1 , x 
 Sp ← a⋅ I − b1⋅ Sp if y = 2 
 y, x y− 1 , x y− 1 , x 
 Sp ← a⋅ I − b1⋅ Sp − b2⋅ Sp if y > 2 
y, x y− 1 , x y− 1 , x y− 2 , x
 
 for y ∈ rows( I) − 2 , rows( I) − 3 .. 0 
 for x ∈ 0 .. cols( I) − 1 
 
 Sm ← a⋅ I if y = rows( I) − 2 
y, x y+ 1 , x
 
Sm ← a⋅ I − b1⋅ Sm if y = rows( I) − 3
 y, x y+ 1 , x y+ 1 , x 
 Sm ← a⋅ I − b1⋅ Sm − b2⋅ Sm if y < rows( I) − 3 
 y, x y+ 1 , x y+ 1 , x y+ 2 , x 
 for y ∈ 1 .. rows( I) − 2 
 for x ∈ 0 .. cols( I) − 1

 
 S
y, x
← Sm
y, x
+ Sp
y, x 
 
 for y ∈ 1 .. rows( I) − 2 
 for x ∈ 0 .. cols( I) − 1 
 Gp ← a0⋅ S if x = 0

 y, x y, x 
 Gp ← a0⋅ S + a1⋅ S − b1⋅ Gp if x = 1 
 y, x y, x y , x− 1 y , x− 1 
 Gp
y, x
← a0⋅ S
y, x
+ a1⋅ S
y , x− 1
− b1⋅ Gp
y , x− 1
− b2⋅ Gp
y , x− 2
if x ≥ 2 
 
 for y ∈ 1 .. rows( I) − 2 
 for x ∈ cols( I) − 2 , cols( I) − 3 .. 0 
 
 Gm ← a2⋅ S if x = cols( I) − 2 
y, x y , x+ 1
 Gm ← a2⋅ S − b1⋅ Gm if x = cols( I) − 3

 y, x y , x+ 1 y , x+ 1 
 Gm ← a2⋅ S + a3⋅ Sm − b1⋅ Gm − b2⋅ Gm if x < cols( I) − 3 
 y, x y , x+ 1 y , x+ 2 y , x+ 1 y , x+ 2 
 for y ∈ 1 .. rows( I) − 2 
 for x ∈ 0 .. cols( I) − 2

 
 Gy ← Gm + Gp 
y, x y, x y, x
 
 for y ∈ 1 .. rows( I) − 2 
 for x ∈ 1 .. cols( I) − 2 
 
 Gx 2 + Gy 2
 ( y , x) ( y , x) 
 G
y, x
← round 
 
 G 
TP 5. 11
Problèmes du programme Filtre de Deriche : . il y a lissage mais pas dérivation

. les valeurs de la norme du gradient sont trop élevées
Etiquetage ( I) ≡
Hough( I) ≡
__________
TP 5. 12
Traitement d'images 6. Introduction à la Reconnaissance Des Formes
6. Introduction à la Reconnaissance Des Formes (RDF)

0. Description de l'image (≡ Extraction de caractéristiques)
L'extraction de caractéristiques constitue le dernier processus de réduction des informations dans l'image avant
Reconnaissance Des Formes (RDF).
Elle est liée à la structure des objets que l'on désire reconnaître.
Ces caractéristiques doivent être à la fois discriminantes et en nombre limité pour réduire occupation mémoire et temps
calcul.
→ Les systèmes de vision actuels sont capables de reconnaître un nombre limité d'objets pour une application donnée.
Démarche de la RDF :
- constituer un vecteur à partir de descripteurs
- comparer ce vecteur d’attributs avec un vecteur modèle
4 étapes dans la RDF :

1. Description → Vecteur d’Attributs
2. Apprentissage
3. Mise en correspondance (Matching) entre Vecteur d’Attributs d’acquisition et Vecteur d’Attributs modèle (Base De Données)
4. Décision (Classification)
On distingue 3 familles de description : 1) description topologique
2) description fonctionnelle
3) description géométrique
Exemple de description topologique et géométrique : graphe des régions avec noeuds et arcs :
Graphe d'adjacences des regions :
Une représentation de l'image, permettant des manipulations en tant qu'information plutôt que sous forme de signal, peut
être apportée par un graphe d'adjacence des régions.
Les manipulations de graphe sont aisées et cette structure est souple et évolutive dans le sens où elle peut s'enrichir et
élaborer de nouvelles informations.
La phase de RDF consiste alors en une mise en correspondance de graphes : le graphe extrait de l’image à traiter et le
graphe modèle de la scène.
2 3
1
1 . surface
. niveau de gris moyen
. centre de gravité
2 3
. rectangle exinscrit
Exemple de graphe représentant 3 régions connexes 2 à 2, et attributs de la région d'étiquette 1.
Composition du graphe
Les noeuds du graphe sont constitués par les étiquettes des régions. Ces étiquettes sont repérées par un entier compris
entre 1 et le nombre des régions. Un noeud n représente donc une région r et possède les attributs suivants :
- l'étiquette e de la région r
- la liste des étiquettes des régions qui sont adjacentes à la région r. Cette liste peut avoir une structure
informatique du type liste chaînée.
- la surface de la région r, son niveau de gris moyen et les coordonnées de son centre de gravité.
- les coordonnées du rectangle exinscrit à la région r.
- la liste des sommets du polygone approchant le périmètre de la région, ainsi que sa forme.
Ces attributs sont autant de renseignements utilisables dans la phase de reconnaissance qui détermine leur choix. Ainsi
par exemple, la liste des étiquettes des régions adjacentes permet de déterminer des ensembles de régions connexes,
susceptibles de représenter chacun un objet.
Ils peuvent être modifiés et étendus pour d'adapter aux besoins.
Les arcs reliant les différents noeuds du graphe matérialisent ces adjacences entre les régions.
6. 1
1. Description de contour
La chaîne numérique (Chain Code) (famille géométrique)
Exemple :
Avec le codage suivant des 8 directions (variante de Freeman) :

1
8 2
7 3
6 4
5
et un démarrage au point A dans le sens indiqué par la flêche, on a le chain code associé au contour :
Chaîne = 88 2 333333 444 66 7777 11 77
- La chaîne dépend du point A → on peut normaliser le chaînage en le considérant comme une séquence circulaire et
en redéfinissant le point A de façon à obtenir l'amplitude la plus faible pour le chaînage
→ Invariance en rotation.
Exemple d’application
La reconnaissance de caractères (OCR) → masque (ET logique) entre le chain code modèle et celui de l’acquisition.
- Codage différentiel
On note maintenant non plus la direction mais la différence entre 2 directions successives :
séquence écrite circulairement (1ère direction comparée à la dernière)
(on applique le modulo n si la différence est négative) (n : nombre de directions possibles dans le codage)
Ex : en 4 connexités (4 directions de codage 0,1,2,3) : 010303223211 → 311311031101

(différence effectuée dans le sens →)
- Des opérations de concaténation de ces chaînes peuvent être effectuées pour notamment réduire le bruit éventuel lors
de la détection
→ Invariance en homotétie (taille, changement d’échelle).
6. 2
L’histogramme des directions de contour (famille géométrique)
Variante du code de Freeman utilisé :

2
3 1
4 0
-3 -1
-2
On notera les 4 pics de l’histogramme des directions de contour (codées selon le code de Freeman à 8 directions, notées
de -3 à +4), correspondant aux 4 régions aplaties du contour, une région quasi-rectiligne donnant un grand nombre de
fois la même direction.
Inconvénient : le caractère statistique de cet opérateur lui fait perdre toute information de localisation.
Descripteur de Fourier (famille fonctionnelle)

On effectue un développement en série de Fourier de la courbure en tout point du contour d'un objet.
Z (s)
Un contour est décrit dans le plan complexe par la fonction Z ( s ) = x( s ) + iy ( s )
s : abcisse curviligne
Intérêt de passer à 1D pour la représentation : calcul d’une TF1D plutôt qu’une TF2D.
 dy 
 
- angle de courbure : ψ ( s) = Arctg  ds 
 dx 
 
 ds 
dψ ( s )
- courbure : c( s) =
ds
s
x( s ) = x(a ) + ∫ c(α ). cos(ψ (α ))dα
a
Sur le contour on a : ( x(a), y(a) : origines A de l'abcisse curviligne).
s
y ( s ) = y (a) + ∫ c(α ). sin(ψ (α ))dα
a
y
ψ
x
c(s ) étant périodique par rapport au périmètre P pour un contour fermé, on a :
i 2π us
∞ −
c( s ) = ∑ K (u ) e P
(développement en série de Fourier) u = −∞
i 2π us
1 P
P ∫0
avec : K (u ) = c( s ) e P ds
La série K (u ) tronquée à une dizaine de termes suffit à décrire le contour.
6. 3
Au lieu de travailler sur la courbure, dont l’intérêt est d’aboutir à une décomposition de Fourier à 1D, on peut
directement manipuler les points (x, y) de l’image (méthode plus directe mais conduisant à une décomposition 2D).
Méthode plus directe (2D)
Im x
y
Re
Tout point est une fonction complexe : Z = x + iy → le contour à N points s'écrit comme une fonction Z à N valeurs.
Si N = 2m → on calcule Z(u) par Transformée de Fourier rapide (FFT) (Z(u) a N termes).
Une Dizaine de termes de Z(u) suffit pour caractériser la forme.
Les propriétés de la TF (Transformée de Fourier) font que Z(u) est normalisable en échelle, rotation et point d'origine A:
- changement d'échelle : → Z(u) multiplié par une constante (FFT linéaire)
θ
- rotation de θ : → Z(u) multiplié par ei
- déplacement de l'origine : → Z(u) multiplié par eikT
(T: 0 → 2π , lorsque A se déplace sur le contour fermé)
Inconvénient de la méthode de Fourier : descripteur sensible au bruit.
2. Descripteur de Surface
Famille topologique
On définit sur l'image :
- le nombre de trous : H
- le nombre de composantes connexes : C
→ nombre d'Euler E = C - H
Ex:
H=1 H=2
C=1 C=1
E=0 E = -1
Exemple d’application : OCR (en associant ce descripteur à d’autres descripteurs)
6. 4
Famille géométrique
Attributs utilisés : - périmètre P, surface S, cercle inscrit etc...
Caractéristiques invariantes en translation, rotation et homotétie :

S
- Rapport de finesse : 4π ⋅
P2
P2
- Compacité :
S
∅
- Rapport du cercle inscrit ou circonscrit au périmètre :
P
Famille fonctionnelle : les moments
Ils prennent en compte l'organisation intérieure des points d'une surface.
Ils sont invariants en translation, rotation et homotétie.
∞ ∞
mpq : moment d'ordre p + q d’une fonction 2D f ( x, y ) : m pq = ∫ ∫ x p y q f ( x, y )dxdy
−∞ − ∞
(moment d'ordre p+q d'une fonction continue f(x,y)).
Application à l'image :
m pq = ∑ ∑ i p j q f (i , j ) f (i , j ) est le niveau de gris

i j
Ex. : objet blanc sur fond noir : f(i,j) = 1 si i,j ∈ objet, 0 sinon.
→ le moment d'ordre 0 est la surface de l'objet : m00 = ∑ ∑ f (i , j ) = S

i j
Les 2 moments d'ordre 1 définissent le centre de gravité ( x, y) de la surface :

 x = m10 / m00

 y = m01 / m00
→ Application à la caractérisation de texture.
Caractérisation de Texture : spectre d'Energie de Fourier
L'attribut énergétique d'un anneau de rayons intérieur r1 et extérieur r2 est donné par :
r2 r2
∑ ∑ F ( u, v )
2
E (r1 , r2 ) =
u =r1 v =r1
N −1
avec les conditions : r12 < u 2 + v 2 < r22 et : 0 < r1 , r2 < (N*M: taille de l'image).
M −1
F(u,v) représente la TFD (Transformée de Fourier Discrète) à 2 D :
M −1 N −1  ux vy 
1 −i 2π  + 
F ( u, v ) =
MN
∑∑ f ( x, y) ⋅ e  M N
pour u = 0 à M-1 et v = 0 à N-1
x =0 y =0
( f(x,y) : niveau de gris ).
6. 5
. variation progressive du niveau de gris BF

v
r2 θ = Arg F(u,v) . variation brutale du niveau de gris
r1 HF
F(u,v)
u
0 (BF : Basses Fréquences ; HF : Hautes Fréquences)
F(u,v)
→ texture régulière a un spectre d'énergie important dans les basses fréquences

→ texture grossière → à variations brutales, a un spectre important dans les HF
- les anneaux énergétiques proches de l'origine 0 correspondent à des textures douces (BF).
- les anneaux énergétiques éloignés de l'origine 0 correspondent à des textures grossières (HF).
Vecteurs d'attributs - Apprentissage

Un vecteur d'attributs doit comporter des descripteurs (attributs) quantifiables vérifiant les conditions :
- être invariants en similitude planes (homotétie, rotations, changement d'origine) pour une reconnaissance
isotrope et indépendante de l’échelle.
- être non corrélés entre eux, pour minimiser la taille du vecteur d’attributs et réduire la redondance.
X Τ = [ x1, x2  xn]T : vecteur d'attributs
L'association vecteur-silhouette forme un modèle ≡ importante compression de l'information.
3. Reconnaissance des Formes et Décision

Introduction :
La Reconnaissance a pour fonction la mise en correspondance du vecteur d'attributs avec un vecteur d’attributs modèle
→ classification. (Ex. d’attributs : longueur de périmètre d’une région, centre de gravité de la région ...)
• Classifieur déterministe :
- Classifieur par fonction de Discrimination g(X) :
C1 X → C1 si g ( X) > 0
Ex. : Problème à 2 classes (≡ 2 décisions possibles) : Règle :
C2 X → C2 si g ( X) < 0
g ( X) = W Τ X − w0 : différence pondérée entre X Modele et X Scène
X Τ = ( x1 , x 2 ...x k ) : vecteur d' attributs à reconnaître ( X Scène )

W Τ = ( w1 , w2 ...wk ) : poids associes aux differents attributs
w0 = W Τ X 0 avec : X 0 = X Modele : Vecteur d’attributs du modèle
- Interprétation graphique (cas k = 2) :

w
1
x1 g ( X) = 0 Frontière :
w2 x2 C1
1:C C2
x2 Σ 1 k = 2 : droite
... wk 0:C 2 Frontière de décision
k = 3 : plan
k > 3 : hyperplan
xk - w0 x1
Décision (seuil)
6. 6
- Classifieur par distance minimale (entre vecteurs XModèle et XScène).
Distance par différence (en valeur absolue), distance Euclidienne, distance de Haussdorf ...
• Classifieur probabiliste :
- Classifieur de Bayes
On fait intervenir la probabilité d'occurrence de X (Voir les méthodes de relaxation).
Schéma général d'une Reconnaissance Des Formes :
Reconnaissance Des Formes
1. Description
ou encore choix du modèle
description description description
(liée au développement du langage naturel)
paramétrique structurale hybride
1 2
(vecteur X d'attributs) Ex. : 3 Maison
paramétrique et
4 5 6
structurale
7
Toit Murs
ex : graphe des régions
seg1 seg3 seg4 seg6

seg2 seg5 seg7
description hiérarchisée (arborescente)
2. Apprentissage :
établir une correspondance entre le nom de l'objet et son modèle et construction du modèle
Elaboration de Règles de Décision, elles sont liées au type de modèle choisi (paramétrique ou structural)
Description paramétrique Description structurale
Vecteur X d'attributs [ x1, x 2 L x k ] L'apprentissage va effectuer des recherches

de chemin minimal (ou de coût minimal) dans un arbre
= 1 point dans un espace de
dimension k
Apprentissage : N observations de
l'objet (modèle)
N modèles
L'apprentissage fournit un nuage
de N points dans l'espace de dim. k en
fonction du bruit présent dans la scène
Apprentissage frontières
optimales entre les différents nuages
issus de plusieurs objets pour y
reconnaître l'objet cherché.
6. 7
Application. Systèmes d'identification de pièces industrielles et d'OCR
1. Identification de pièces industrielles

Préliminaires
L'objectif d'un système d'identification de pièces est de déterminer la nature, la position, l'orientation de celles-ci, quand
elles sont présentées isolément devant une caméra (en défilant sur un transporteur à bande) ou bien quand elles sont en
vrac planaire avec recouvrement.
A propos des pièces en vrac, on s'est aperçu que leur reconnaissance était souvent très complexe. La tendance actuelle
est de les ranger au péalable mécaniquement par trémie, automate ou à la main. Des systèmes très fiables (palette de
rangement pour grosses pièces, étui ou boîte de présentation pour composants électroniques, carousel etc...) les montrent
alors une par une à la caméra.
En outre l'éclairage des objets en milieu industriel est toujours difficile à réaliser (problèmes d'ombre ...). Il faut lui
consacrer beaucoup de soins pour que l'opération réussisse.
Une approche classique et qui a fait ses preuves, est basée sur le codage polaire du contour de l'objet isolé. Quand le
codage est acquis, on calcule les coodonnées du centre de gravité G, puis on détermine la distance de chaque point du
contour à G en fonction de la direction. On obtient ainsi la signature polaire qui, après un traitement convenable,
détermine la reconnaissance et l'orientation de la pièce.
Cette opération suppose que l'on dispose de moyens suffisants et rapides pour relever le contour: en premier lieu, une
caméra à définition adaptée à l'echelle de la pièce comportant 128² ou 256² pixels et ensuite un logiciel de traitement
d'image qui, après filtrage préalable et calcul des gradients, donne de l'objet un contour continu, exprimé par exemple à
l'aide d'une chaîne numérique (chain-code). Une squelettisation est souvent nécessaire pour obtenir un contour sans
équivoque.
La définition précise du point G est très importante pour la qualité de la signature ; la moyenne des coordonnées (x,y)
des points de contour ne suffit pas à la précision requise.
Il faut calculer les moments d’ordre 1 en plus.
Il faut tenir compte des erreurs provenant de la contribution des points du contour à sa longueur efficace. Chaque point
est affecté d'un poids représentant sa contribution réelle à la longueur du contour; les poids découlent de considérations
géométriques élémentaires et sont consignés dans la table ci-dessous.
Un simple cumul du nombre de pixels d’un contour ne donne pas une mesure précise de la longueur de ce contour. Il
faut procéder à des corrections du poids d’un pixel selon sa disposition dans un contour :
6. 8
Configurations géométriques Longueur efficace du pixel-contour Poids
5/2
2/2
La pondération des points est aussi un moyen de rendre la mesure de la longueur du contour indépendante de
l'orientation relative de l'objet par rapport aux axes de la trame de la caméra.
La longueur de contour est une donnée fondamentale de la forme et de la dimension de l'objet et est mise à profit pour
son identification.
La signature polaire
Mi
M
M' α
G x
Le centre de Gravité G peut être obtenu à l’aide des moments d’ordre 1.

→
Considérons une pièce non forcément convexe; on fait passer par G un vecteur GM qui balaie le contour avec un pas
angulaire ∆α = 2π/N.
Un vecteur à N composantes est formé en relevant pour chaque direction la ou les distances de G aux points M, M1,... Mn
→
du contour. Le vecteur GM (α ) qui est la signature polaire de la pièce est périodique (T = 2π).
6. 9
Il représente le contour extérieur de la pièce (Fig.1) (ou le contour intérieur, ou encore la moyenne des contours
→
GM i sont triés à l'aide d'un algorithme qui combine le plus petit, le
intérieur et extérieur) si les différents vecteurs
→
plus grand, la valeur moyenne, la somme pondérée des GMi pour ne retenir que le seul contour GM significatif :
GM
Fig.1
Orientation et identification de la pièce
La première méthode consiste à comparer la signature relevée à une signature obtenue par apprentissage de la pièce
dans une position de référence.
La deuxième méthode est basée sur l'estimation de l'axe de symétrie maximale passant par le centre G. Sa direction θ p
est celle pour laquelle la composante impaire de la signature donne une contribution minimale (Fig.3).
La contribution est déduite de l'évaluation de la fonction :

N  → → 
X (θ j ) = ∑ GM (α i + θ j ) − GM (− α i + θ j ) avec j = 0, 1,.... ... ..., N-1.
i =1  

X (θ ) est minimale pour θ = θ p

X (θ ) est une fonction périodique de période π
→
On construit alors la signature polaire : GM (α + θ p ) , permettant ainsi de normaliser la signature polaire pour le
calcul de l’orientation de la pièce.
La détermination de l'axe de symétrie maximale n'est pas suffisante pour connaître l'orientation de la pièce (erreur de
±π) et sa face.
On peut lever ces indéterminations en comparant point par point la signature avec la signature de référence, suivant
quatre situations qui découlent des coïncidences d'axe de symétrie obtenues par permutation circulaire des objets
observés (Fig.2).
6. 10
Face 1 position 1
Face 1 position 2, après rotation de 180°
Face 2 position 1
Face 2 position 2, après rotation de 180°
Fig.2
Quatre conclusions découlent des comparaisons (Fig.2) :

- Les 2 pièces sont vues par la même face et leur décalage angulaire est < 180°
- Les 2 pièces sont vues par la même face et leur décalage angulaire est > 180°
- Les 2 pièces sont vues par 2 faces opposées, mais leur décalage est inférieur à 180°, à un retournement près.
- Les 2 pièces sont vues par 2 faces opposées, mais leur décalage est supérieur à 180° .
- Le dernier cas est celui de la non ressemblance : la pièce est rejetée.
Il faut donc faire une signature polaire par face.
GM (α)
π α
X(θ)
direction de l'axe de
symétrie max.
θp π θp + π θ
GM (θ p +α)
Fig.3
La précision sur l'estimation de l'orientation de l'objet, est fonction du nombre de pas N du codage polaire.
La détermination de l'orientation et de l'identification de la face d'une pièce correspond à une complexité plus petite que
celle demandée par les méthodes de comparaison circulaire des signatures.
6. 11
Si N est le nombre d'échantillons (ou de pas), les complexités sont les suivantes :
- orientation de l'objet = O(N²)
- orientation et identification de face = O(2N²)
- méthode de l'axe de symétrie = O(N²/4 + 4N)
L'avantage de la méthode d l'axe de symétrie devient évidente dans le cas de la reconnaissance d'un objet par
comparaison avec plusieurs références; en particulier la méthode de l'axe conduit à un calcul de l'orientation, ramené à
une seule tentative, de complexité : O(N²/4), et la comparaison avec chaque référence se résume alors aux quatre
comparaisons statiques avec une complexité : O(4/N).
ANIMA est un système industriel de reconnaissance par signature polaire; il évalue la distance d entre la signature
normalisée (dont l'origine α du périmètre p, est translatée d'une moyenne <α>) et la signature considérée.
α A ( p ) − α B ( p ) dp
pL
d =∫
p =0
Pour trouver le ninimum de d, on calcule la corrélation sur le périmètre total pL ;

le temps de l'opération est de 1 sec./objet.
2. Reconnaissance d'écriture (OCR Optical Character Recognition)
2.1. Introduction
Depuis deux décennies, de nombreuses investigations ont été consacrées à la reconnaissance de textes écrits.
Ce problème se divise en deux :
- la lecture optique de textes dactylographiés;

- la reconnaissance et le déchiffrage de textes manuscrits.
Actuellement, il existe des lecteurs optiques commerciaisés allant des types spécialisés dans la lecture d'une ou plusieurs
polices de caractères, jusqu'aux lecteurs intelligents capables d'apprendre à lire tout texte dactylographié.
Par contre, les études portant sur la reconnaissance d'écriture manuscrite n'ont pas encore abouti, à l'exception de
l'écriture script non cursive; dans cette façon d'écrire à la main, les lettres sont dessinées séparément dans des cases et
reconnaissables à l'aide de critères morphologiques comme les courbes, boucles, croisements, lignes continues.
Signalons à ce propos l'existance d'un lecteur mis au point par FELLER Inc., le PC-OCR 4001, et les réalisations de la
société AI Visions Systèmes en France.
Le problème de la lecture par ordinateur est très vivant, car il se pose avec acuité à toute la civilisation asiatique qui
utilise des idéogrammes à la place des caractères phonétiques.
La Chine, le Japon, la Corée sont confrontés à des problèmes de lecture rapide, de traduction et de compatibilité des
textes.
Dans les pays occidentaux, des besoins existent aussi et concernent essentiellement le tri postal, l'aide aux aveugles, la
saisie optique de textes ou simplement de chiffres (lecture fiable et automatique de chèque, de fiche de contrôle etc...).
Normes d'écriture
En 1960 aux USA, l'American National Standards Institute a développé la norme OCR-A (Optical Character
Recognition A) et en 1965 l'Association Européenne a proposé la norme OCR -B.
Il faut reconnaître que le nombre de polices de caractères est très vaste et chaque grande société a développé la sienne
(IBM, BURROUGHS, DEST DATA, COMPUSCAN, FELLER, HENDRIX...); le nombre de fontes est tel que, sans
une normalisation plus contraignante, aucune machine de lecture ne pourra être sur le marché à prix raisonnable.
6. 12
2.2. Reconnaissance des caractères scripts
Comme dans tout procédé de Reconnaissance Des Formes, on retrouve les 3 étapes fondamentales :
- Prétraitement, Squelettisation,
- Extraction de primitives,
- Classification.
La prise de vue et l'extraction de contour étant considérées comme exécutées, la squelettisation de chaque caractère doit
être obtenue par des méthodes rapides, souvent empiriques mais cette opération ne doit pas altérer les caractéristiques
topologiques du caractère, en particulier la connexité de son contour.
Extraction de primitives
L'objectif de l'opération est la mise en évidence de particularités locales ou globales qui seront utilisées ensuite pour
l'identification. Le caractère est observé dans une matrice de points (Fig 5) dont on extrait les caractéristiques qui se
prêtent le mieux à une description mathématique.
Les paramètres caractéristiques doivent permettre de distinguer des formes proches de caractères différents, mais tolérer
des variations d'échelle.
Extraction de trait
à travers une matrice
Extraction de points d'intersection
par droites aléatoires
Fig 5
Les tests et leur primitives
Algorithme de JUNG PYO HONG
Il s'agit de tracer l'histogramme de la fréquence f des droites ayant n points d'intersection avec le caractère d'épreuve
(Fig 7A).
On utilise environ 50 droites aléatoires ; le caractère est coupé par plusieurs droites dont la répartition est désordonnée.
Chaque intersection est considérée comme un point. Le nombre de points est compté et tracé sous forme d'histogramme
(Fig 7B) qui représente la fréquence des droites ayant n points d'intersection. L'histogramme est comparé à celui d'un
caractère-référence. Un test statistique valide ou rejette le caractère-épreuve. Cet algorithme, à priori singulier, donne
d'excellents résultats.
6. 13
f
distibution d' après l'épreuve
distibution du caractère référence
A B 0 1 2 3 4 5 6 n
Fig 7A et 7B
Méthode du masque
Le procédé permet d'associer à tout caractère un nombre binaire sur 12 bits par exemple. On utilise une matrice de 3 x 4
masques pour analyser les caractères épreuves (Fig 8).
Ce procédé s'apparente aux méthodes dites “ des k plus proches voisins ” parce que, encore dans ce cas, le résultat tiré
de l'épreuve sera comparé à un nombre provenant du caractère-référence.
1 2 3
4 5 6
7 8 9
10 11 12
Masques 1 2 3 4 5 6 7 8 9 10 11 12
Caractères Nombre binaire
I 0 1 0 0 1 0 0 1 0 0 0 0
O 1 1 1 1 0 1 1 1 1 0 0 0
Q 1 1 1 1 0 1 1 1 1 0 0 1
C 1 1 1 1 0 0 1 1 1 0 0 0
Fig 8
La comparaison des nombres binaires de l'épreuve et de la référence est un test statistique qui valide ou non le caractère.
Pour un alphabet alphanumérique, le nombre de masque pourra dépasser 12. Suivant les différentes polices qui
définissent un style de caractères (italique, romain, gothique, gras, maigre, etc...) le lecteur optique doit conserver en
mémoire tous les caractères, ce qui est peu économique en case mémoire et en temps de traitement.
Il suffit de faire un ET logique entre le code référence et le code d’acquisition du caractère pour la reconnaissance.
Application : Apprentissage à l’aided’un Réseau de Neurones Artificiel (RNA) à 12 entrées - 12 neurones d’entrée (12
pixels) et 26 sorties - 26 neurones de sortie (26 lettres de l’alphabet latin).
6. 14
Méthode du graphe et de l'arbre étiqueté
Après squelettisation, le caractère est réduit à un ensemble de segments de droites symboliques. La direction de chaque
segment est déterminée par un code de Freeman (a, b ,c..., g ,h); le caractère est ensuite développé en un graphe étiqueté
(Fig 9C) qui constitue l'étape intermédiaire de la réduction.
A)
f
g e
h d
B)
a c
$
a c
a c
a d c
C) a d c
Fig 9
A) : squelettisation
B) : code de Freeman
C) : construction de l'arbre
Les étiquettes a, b, c, d ... d’un segment représentent l’orientation de ce segment.
(on peut rajouter la longueur du segment de droite en plus de l’orientation).
Pour transformer le graphe en arbre étiquetté, MICLET recommande deux principes :
1 - chaque arc du graphe est traduit en un ou plusieurs noeuds de l'arbre par une discrétisation en longueur et direction.
2 - les boucles éventuelles du graphe sont dépliées pour créer l'arbre.
Dans le cas du caractère A de la Fig 9C, A devient un arbre dont le sommet est étiquetté par un $ dont les branches sont
raméfiées en lignes de noeuds ou fourches binaires.
La validation du caractère par son arbre s'obtient par le calcul de la distance entre arbres de l'épreuve et de la référence;
c'est une méthode utilisée en taxonomie qui demande moins de temps de calcul mais exige un nombre optimal de
critères, faute de quoi la validation est affectée d'un faible coefficient de vraisemblance.
La distance entre arbres est par définition le coût de la suite d'opérations la moins coûteuse transformant un arbre en un
autre. Deux algorithmes sont utilisés pour l'évaluation de la distance; celui de SELKOW et celui de LU. Nous
développons dans ce qui suit, des opérations de l'algorithme de Selkow .
Considérons un arbre comme une phase récursive de sous-arbres ; un arbre est un ensemble fini de n noeuds tels que
parmi les n il en existe un seul noté racine R et tels que les autres noeuds soient groupés en ensembles disjoints N1,
N2,... Nm , qui sont eux-même des arbres reliés à R par un arc.
6. 15
6
1 4
2 3 5
Dans l'arbre ci-dessus, R étant la racine, les sous-arbres sont N1 = (1, 2, 3), N2 = (4, 5) et N3 = (6);
(1, 2, 3) est à son tour un arbre de sommet (1) et de sous-arbres (2) et (3).
Dans cette famille d'arbres étiquetés sur n, on distingue :

- N le noeud racine : R
- les noeuds restants N1,......Nm qui sont tous des sommets d’arbres;
L'étiquette de chaque noeud est λ(n), n∈N et λ(N) est l'étiquette de la racine N.
L'arbre N(i) est l'arbre obtenu en enlevant les sous-arbres Ni+1 ... Nm.
Dès lors, on peut admettre :

a) deux arbres T1 et T2 sont égaux, (notation : T1 = T2) quand λ(T1) = λ(T2)
b) T11... T1p étant les sous-arbres de T1
T21... T2m étant les sous-arbres de T2
Si m = p, alors deux arbres égaux vérifient T1i = T2i pour 1 ≤ i ≤ m.
Différentes opérations sont possibles sur l'ensemble des arbres étiquetés; leurs noeuds sont les λ(n) = ak;
avec a = { a1...an}; N1, .....Nm sont les sous-arbres de N.
Changement d'étiquette :
L(am, ai) est une opération définie par les conditions ci-après, qui transforment N en N* :
λ(N*) = ai
N1, ... Nm sont les sous-arbres de N*
Insertion de sous-arbres :
I(T) est l'opération appliquée à N à l'indice i (1 ≤ i ≤ m) qui transforme N en N* en respectant les conditions :
λ(N*) = ai
N1, ... Ni ,A, Ni+1......Nm sont les sous-arbres de N*
Destruction de sous-arbres :
D(Ni ) est l'opérateur qui transforme N en N* sous les conditions :
λ(N*) = ai
Ni, ... Ni-1, Ni+1 ... Nm sont les sous-arbres de N*
Chaque opération est affectée d'un coût positif.

CL = C(i,k) est un tableau des coûts représentant le changement de l'étiquette ai en ak.
CD (ai ) est le coût élémentaire de destruction d'un arbre réduit au noeud étiqueté ai.
CI (ai ) est le coût élémentaire de l'insertion d'un arbre réduit au noeud étiqueté ai.
L'évaluation des coûts CD et CI est donnée par les formules suivantes :
C I (T1 ) = ∑ C I (λ (n ))
n∈T1
6. 16
Ces opérations permettent d'évaluer le coût d'une insertion I(T).
C D (T1 ) = ∑ C D (λ (n ))
n∈T1
La transformation d'un arbre en un autre s'obtient par une suite d'opérations CL, CD, ou CI affectées chacune d'un coût.
La distance ∆(T1, T2) entre deux arbres étiquetés T1et T2 est le coût de la somme la moins chère de ces opérations pour
passer de l'arbre initial à l'arbre final.
L'algorithme de LU fondé sur les mêmes principes, offre des opérations élémentaires qui ont chacune un coût
intrinsèque (indépendant du noeud) :
1 - Suppression d'un noeud à un endroit quelconque dans l'arbre :

a a
b c
2 - Insertion dans les mêmes conditions :

a a
d c
b c
b
3 - Changement d'étiquette.
La distance ∆ entre arbres est définie ici, comme le coût de la suite d'opérations la moins chère pour passer d'un arbre à
l'autre; cependant les opérations doivent remplir les conditions suivantes.
Considérons les noeuds N1 et N2 d'étiquettes a1 et a2, transformés par opérations élémentaires en N'1 et N'2 d'étiquettes a'1
et a'2.
Les conditions sont au nombre de trois :
i) N1 = N2 ↔ τ(N1) = τ(N2),
ii) la transformation τ préserve l'ordre de père à fils,
iii) la transformation τ préserve l'ordre postfixé (en largeur d’abord), c'est à dire l'ordre qui ordonne de parcourir en
ordre postfixé le premier sous-arbre de la racine (définition récursive) et aussi d'examiner la racine.
L'alogrithme de LU, plus complexe que celui de Selkow, est efficace et rapide.
Exemple :
d
b e f g
a c
L'ordre postfixé s'écrit : a c b e f g d.
6. 17
Exemple de distance entre arbres α et β : correspondant auxcaractères :

α β
$
$ et
α β
a d a c
d et
b a d c a a c
d
b a c
d d
1. Suppression du
α= $
noeud d'étiquette b
$
2. Insertion noeud a
$
a d a d a d
b d
a d
d
3. Remplacement du $ $
noeud d par le noeud c 4. Insertion noeud c = β
a c a c
a d a d c
distance = 4 ( = 4 transformations)
Amélioration possible :
Faire intervenir : - l’étiquette pour le calcul de la distance
- la longueur des segments ...
Exemples : (les étiquettes a, b, c, d représentent l’orientation des segments) :
Construction de l'arbre correspondant à la lettre A
Caractère squelettisé Discrétisation en Développement

graphe en arbre
$
a c
d
a c
c
a
a d c
Le sommet de l’arbre est le sommet k situé le plus haut (et le plus à gauche aussi si k n’est pas unique) dans les segments d’approximation
polygonale.
6. 18
Construction de l'arbre correspondant à la lettre C.
Caractère squelettisé Discrétisation en Développement

graphe en arbre
$
a
b
a b
b b
e
d
d
On peut réaliser des opérations de concaténation sur le graphe ou l’arbre.
Méthode de reconnaissance par arbre de classification
Le principe de cette méthode est utilisé par exemple pour la reconnaissance des 10 chiffres
(0, 1, 2, .....8, 9) ; il se décompose en 2 étapes :
a) apprentissage des chiffres au travers d'une matrice et construction d'un arbre à n décisions binaires.
b) application des tests de l'arbre à la reconnaissance de chiffres inconnus.
Ce principe peut facilement être étendu à un alphabet complet, qui lui-même peut comporter plusieurs polices de
caractères, au détriment de la complexité des calculs.
a) L'apprentissage et l'arbre à n décisions (descripteur)
Soit N = 10 les chiffres inscrits dans une matrice de masques (5 x 4).

Chaque masque (i, j) est pondéré par la fréquence des chiffres qui le remplissent :
1 2 3 4
1 8 9 10 5 j
2 5 2 3 5
3 6 5 9 5
4 4 3 3 6
5 8 9 9 6
L'arbre est caractérisé par des noeuds qui représentent chacun un test binaire de remplissage
(0 pour non remplissage ou 1 pour remplissage).
Ainsi, à chaque tête de sous-arbre, le test local divise les chiffres en deux catégories selon qu'ils vérifient le test ou non.
La racine de l'arbre est placée sur le premier masque (i, j) rencontré dans la matrice, qui est affecté du nombre N/2
(ici N/2 = 5) (car N/2 divise l’ensemble en 2 sous-ensembles de même taille);
c'est le masque de coordonnées (i,j) = (1,4).
Le test binaire sépare les N chiffres en deux sous-arbres, l'un (1) contient les chiffres remplissant le masque et l'autre non
(0).
6. 19
Ensuite il suffit d'aller sur le masque qui à son tour discrimine en deux sous-arbres les chiffres restant
(le masque (2,1) est applicable aux 2 sous-arbres) et ainsi de suite. Dans cet exemple, la méthode fait apparaître 9 tests
répartis sur un arbre de profondeur à n lignes; n = 3.
Le premier test est noté n = 0 ; il y a 2n + 1 tests : (voir l'arbre de décision ci-après)
0 1
(1,4) n=0
0,2,7,8,9
1,3,4,5,6
0 1 0 1
(2,1) (2,1) n=1
5,6 0,8,9
1,3,4
2,7
0 1 0 1 0 1 0 1
(2,2) (4,1) (1,1) (4,1) n=2
4,1 0,8
3 6 2 7 9
5
0 1 0 1
(1,1) (3,2) n =3
3 4 1 5 6 2 7 9 0 8
→ Le chiffre 8 est codé : 1 1 1 1

le chiffre 3 est codé : 0 0 0
le chiffre 6 est codé : 0 1 1
b) Application de l'arbre à la reconnaissance
La matrice est appliquée à un chiffre inconnu et l'on pointe la fréquence des masques (1,4) (2,1) (2,2) (4,1) (1,1) et (3,2)
en une séquence appropriée au cas (calcul du chemin).
La puissance de discrimination est 2n ; la méthode et rapide, mais elle est sensible aux petites variations de forme; pour
corriger ce défaut, il suffit d'augmenter le nombre de masques par matrice, au détriment de la complexité.
2.3. Réalisations commerciales

Il existe environ une dizaine de constructeurs de lecteurs optiques de caractères :
Constructeurs Type de lecteur Vitesse (cps)
REDIFON R500 3000
SCAN DATA 2800 2400
SCAN OPTICS 540 2000
INFORMATION INTER'L Graphix 1000
BURROUGHS 1200 400
DEST DATA OCR WORD 200
FELLER OCR 200
AL VISION SYSTEMES Licence CIT Alcatel 150-300
KURZWEIL KDEM (Penta systemes) 150
COMPUSCAN Alphaword 3 120
CAERE - -
RECOGNITION EQUIPMENT INC REI -
__________
6. 20
Traitement d’Images
ANNEXE
Annexe
Traitement d'images 3 Annexe. Segmentation des images
3 ANNEXE. Segmentation des images

1. Performances d'un détecteur linéaire de contours
Dans cette étude, on va se donner des critères théoriques permettant d'évaluer les performances de détecteurs linéaires
de contours et de comparer leurs performances.
A cet effet, on ne va s'intéresser qu'à la partie dérivation du filtre (partie essentielle).
La partie lissage est occultée pour simplifier les comparaisons (mais elle peut combinée avec la dérivation pour être
prise en compte par les mêmes critères).
La partie seuillage est non linéaire et ne peut être soumise à ces critères basés sur la RI du filtre.
Critères théoriques d'évaluation des performances
1.1. Introduction
Les performances d'un opérateur de détection de contour peuvent être décrites pour un type d'application précis. Pour
être plus général, on peut fixer un certain nombre de critères qui peuvent être la finesse des contours obtenus, la rapidité
de l'opérateur, etc...
Pour prédire les performances d'un opérateur, nous avons utilisé les critères théoriques proposés par Canny, qui sont
parmi les plus représentatifs : qualité de la détection, de la localisation et de la non multiplicité des réponses de
l'opérateur.
Cette prédiction nécessite cependant la connaissance de la Réponse Impulsionnelle (RI) du filtre, limitant ainsi
l'application de ces critères aux opérateurs linéaires.
Pour les opérateurs non linéaires, des critères de performances expérimentaux peuvent être définis en utilisant des
images de test, avec un bruit additif connu.
La rapidité du filtre (obtenue d'après le nombre d'opérations par point) ainsi que sa complexité (difficulté
d'implémentation de l'algoritme sur circuit câblé) constituent des critères de performances également importants.
1.2. Critères d'évaluation des opérateurs linéaires
Parmi les différents types de contours idéaux, Canny choisit de détecter un contour dont le modèle est un échelon s(x)
d'amplitude A, noyé dans un bruit additif n(x), blanc, gaussien, de moyenne m nulle (bruit centré) et de variance
n02 = E([n(x)-m]2) = E([n(x)]2).
s(x)
A
x
modèles de transition escalier, ou rampe toit pointe

sur une ligne d'image saut, ou échelon
Variations d'intensité lumineuse dans les contours idéaux.
3 Annexe. 1
1.2.1. Filtres continus
Canny définit 3 critères pour évaluer la réponse d'un filtre 1D de RI continue f(x), au signal bruité i(x) :
1) le critère de détection, caractérisé par le rapport signal sur bruit S/B à la sortie du filtre :
la réponse os(x = 0) du filtre à l'endroit exact où se situe le saut d'amplitude, au signal utile s(x) seul, est donné par la
relation de convolution :
+∞
oS ( x = 0) = ∫ f (u). s( x − u)du  = A. ∫ f (u)du
0
 −∞  x = 0 −∞
La réponse on(x = 0) du filtre à cette même origine, au bruit n(x), est caractérisé par l'espérance (écart-type de on(x )) :
{∫ }
1/ 2
   +∞  
2 1/ 2
(u)du. E ([n( −u)])
+∞ +∞

  ∫−∞ ( ) ( )   (u)du
2
 − = = n0 ∫
2 2
E f u . n u du f f
    −∞ −∞
car
E ([n( − u)]) = n02
2
Le rapport signal sur bruit S/B en sortie du filtre , exprimé en valeur absolue, s'en déduit en fonction du rapport signal
sur bruit A/n0 à l'entrée, et sera caractérisé par la grandeur Σ :
f ( x )dx f ( x )dx
0 0
∫ ∫
S/B=
A −∞
+∞
=
A
∑ avec : ∑= −∞
+∞
n0
∫−∞
f 2
( x)dx n0
∫−∞
f 2
( x )dx
La détection sera d'autant meilleure que le rapport Σ sera élevé.
2) Le critère de localisation, qui évalue la distance des points détectés au centre réel du contour.
Une bonne localisation sera obtenue en maximisant le rapport Λ, déduit de la grandeur L ainsi définie :
A f ′ ( 0) A f ′ ( 0)
L= = Λ avec : Λ=
+∞ +∞
f ′ 2 ( x )dx ( x)dx
n0 n0
∫ ∫ f′ 2
−∞ −∞
3) Le critère d'unicité de la réponse, qui mesure la distance D entre les pics de la réponse du filtre à un contour unique.
On cherchera à maximiser l'inverse ∆ de cette distance D, donnée par la relation :
+∞ +∞
∫ f ′ 2 ( x )dx ∫ f ′′ 2 ( x )dx
−∞ −∞
D = 2π = 2π ∆ −1
avec : ∆=
+∞ +∞
∫ f ′′ ( x )dx
2
∫ f ′ 2 ( x )dx
−∞ −∞
3 Annexe. 2
Détection d'un contour en forme de saut d'amplitude :
a) le signal d'entrée : a1) non bruité s (x) a2) bruité s ( x) + n( x)

b) la Réponse Impulsionnelle (RI) f (x) du filtre détecteur (dérivateur)
c) la sortie o(x ) du filtre : c1) o s au signalnon bruité s ( x) c2) o s + o n au signal d'entrée bruité s ( x) + n( x)
s s+n
a1) x a2) x
f
f
b) x x
b)
os os + on
x
c1) x c2)
D
1.2.2. Filtres discrets
Les critères précédents font intervenir une expression continue f(x) de la Réponse Impulsionnelle (RI) du filtre.
Pour les appliquer à des filtres dont apparaît directement, au regard du masque de convolution utilisé, la RI discrète f(n),
on a d'abord cherché à déduire la RI continue f(x) équivalente de ces filtres.
Ainsi, par exemple, pour le filtre de dérivation utilisé par Sobel :
-1 0 1
-2 0* 2
-1 0 1
ramené à 1D :
-2 0* 2 (*) point central du masque
La réponse y(p) du filtre à la séquence d'échantillons x(i) donne directement la RI f(n) du filtre :
y(p) = 2[x(p + 1) - x(p - 1)] et f(n) = 2[δ (n + 1) - δ (n - 1)]

δ (n) = 1 si n = 0
où δ(n) représente le symbole de Kronecker : 
δ (n) = 0 sinon
On en déduit la RI continue f(x) du filtre de Sobel 1D, en fonction de la période d'échantillonnage T :

f(x) = 2 [δ (x + T) - δ (x - T)]
δ ( x ) = ∞ si x = 0
où δ(x) représente la distribution continue de Dirac : 
δ ( x ) = 0 sinon
3 Annexe. 3
Cependant la distribution de Dirac n'étant pas de carré sommable, les formules continues proposées par Canny ne sont
pas directement applicables et nous avons alors utilisé le domaine fréquentiel pour évaluer les critères.
Ainsi, pour calculer le rapport signal sur bruit (S/B) par exemple, nous avons déterminé la réponse os (x = 0) du filtre à
l'endroit exact du saut d'amplitude, au signal utile s(x) seul, par Transformation de Fourier Inverse (TFI) de la réponse
dans le domaine fréquentiel :
oS ( x = 0 ) = TFI [F (ν ).S (ν )]x =0 =  ∫ F (ν ).S (ν ).e i 2πνx dν  = ∫ F (ν ).S (ν )dν

+∞ +∞
 −∞  x =0 −∞
où F(ν) représente la Fonction de Transfert (FT) du filtre (Transformée de Fourier (TF) de la RI f(x) du filtre), et S(ν) la
TF du signal s(x) :
+∞ +∞
F (ν ) = ∫ f ( x).e −i 2πνx dx et : S (ν ) = ∫ s ( x).e −i 2πνx dx
−∞ −∞
La réponse on (x = 0) du filtre, à cette même origine, au bruit n(x), est caractérisée par la fonction d'autocorrélation Cx (a =
0) :
C x (a = 0 ) = E [n( x ).n( x − a )]a =0 = C x (a = 0 ) = C (a = 0 )

en faisant l'hypothèse d'un bruit qui est ergodique, et stationnaire à l'ordre deux (≡ moyenne et variance stationnaires).
Pour un signal d'énergie finie, la fonction d'autocorrélation C(a = 0) s'obtient par Transformation de Fourier Inverse
(TFI) de la densité spectrale Γ(ν) du bruit en sortie du filtre, elle-même fonction de la densité spectrale γ(ν) du bruit à
l'entrée :
Γ(ν ) = γ (ν ). F (ν ) γ (ν ) = n02
2
avec :
C (a = 0 ) = TF -1 [Γ(ν )]a =0 = n02 .∫ F (ν ) .e i 2πνa dν  = n02 .∫ F (ν ) dν

+∞ 2 +∞ 2
 −∞  a =0 −∞
Le rapport signal sur bruit (S/B) en sortie du filtre s'exprime alors, en valeur absolue, par la relation :
F (ν ).s (ν )dν
+∞
oS ( x = 0 ) ∫−∞
S/B = =
C (a = 0 ) +∞
F (ν ) dν
∫
2
n0
−∞
Pour un signal périodique, et c'est le cas qui nous intéresse ici car le module de F(ν), qui est la Tranformée de Fourier de
distributions de Dirac décalées dans le temps, est périodique de période ν0=1/T :
TF
→
f(x) = 2[δ (x + T) - δ (x - T)] F(ν ) = 2[e i2πνT - e -i2πνT ] = 4i.sin(2πνT)
on a la définition suivante pour l'autocorrélation :
2 ν /2
1  2 ν0 / 2
C (a = 0) = n0 .∫−ν / 2 F (ν ) .e  n F (ν ) dν
2 i 2πνa
dν = .∫
0 0 2

ν0  0 
 a =0 ν 0 0
−ν / 2
F (ν ).S (ν )dν
+∞
oS ( x = 0 ) ∫ −∞
et le rapport signal sur bruit (S/B) devient : S/B = =
C (a = 0) n0 ν0 / 2
F (ν ) dν
∫ν
2
ν0 − 0 /2
3 Annexe. 4
On verra que les calculs occasionnés par cette méthode sont relativement lourds, et il est préférable de prendre plus
simplement l'équivalent discret des formules continues de Canny pour appliquer les critères aux filtres discrets.
Les critères s'écrivent alors très simplement, pour un filtre discret de RI f(n) :
0 +∞
∑ f (n )
n = −∞ f ′(0 ) ∑ f ′′ (n )
n = −∞
2
Σ= Λ= ∆=
+∞ +∞ +∞
∑ f (n ) ∑ f ′ (n ) ∑ f ′ (n )
2 2 2
n = −∞ n = −∞ n = −∞
Détection Localisation Unicité de la réponse
1.3. Application des critères sur l'opérateur de Sobel
Appliquons les 3critères de performances précédents à l'opérateur dérivateur discret de Sobel dont on ramène la RI à
1D pour appliquer simplement ces critères :
Filtre de Sobel 2D : Filtre de Sobel ramené à 1D :

-1 0 1 -2 0* 2
-2 0* 2
-1 0 1 (*) point central du masque
RI discrète : f(n) = 2[δ(n+1) - δ(n-1)] ou d'équivalent continu : f(x) = 2[δ(x+T) - δ(x-T)]
1- Détection :
On trouve simplement le résultat en appliquant la forme discrète du critère :

0
∑ f (n )
n = −∞ 2 1
Σ= = = ≈ 0.71, inférieur à 1 ! (Rapport S/B faible).
+∞
2 2 2
∑ f (n )
n = −∞
2
On peut vérifier en utilisant la formule fréquentielle donnant Σ :

+∞
∫ F (ν ).S (ν )dν
−∞ A
S/B = = ∑
ν0 / 2
F (ν ) dν
n0 n0
∫ν
2
ν0 − 0 /2
On calcule pour cela le gain complexe (FT) F(ν) du filtre :

F(ν) = TF[RI continue f(x)] = 4i.sin(2πνT), dont le module a pour période ν0 = 1/T.
En utilisant le fait que :

+∞
sin x x sin( 2ax)
∫ dx = π et : ∫ sin
2
(ax)dx = −
−∞ x 2 4a
on déduit l'expression du rapport signal sur bruit (S/B) du filtre :
2A A 1 1
S/B = = qui donne bien le rapport : ∑ = ≈ 0.71
2n 0 2 n 0 2 2
3 Annexe. 5
2- Localisation :
La dérivée discrète de la RI f(n) est définie par :
f ′(n) = f(n + 1) - f(n) = 2[δ (n + 2) - δ (n + 1) - δ (n) + δ (n - 1)]
et on tire :
f ′(0 ) 2
Λ= = = 0 .5
+∞ 4
∑ f ′ (n )
n = −∞
2
3- Unicité de la réponse :
La dérivée seconde de la RI du filtre de Sobel est donnée par :
f ′′(n ) = f ′(n + 1) − f ′(n ) = 2[δ (n + 3) − 2δ (n + 2) + 2δ (n)− δ (n − 1)]

et impose, en mettant à profit les calculs effectués pour la localisation :
+∞
∑ f ′′ (n )
n = −∞
2
10
∆= = ≈ 1.58
+∞ 2
∑ f ′ (n )
n = −∞
2
Récapitulatif des résultats de l'opérateur de Sobel aux 3 critères :
Détection : Σ
Σ = 1/ 2 _______ 0.71
Localisation : Λ
Λ = 1/ 2 ______ 0.5
Unicité de la réponse : ∆
∆ = 10 / 2 _______________ 1.58
3 Annexe. 6
2. Nouvelle approche de détection de contours : critère optimal de Canny - Filtre de Deriche
Rappel : implémentation d’un filtre RII
L’implémentation d’un filtre RII peut se faire de 2 manières :

- sous forme non récursive en tronquant la RI sur un masque de taille finie pour rendre l’algorithme
programmable
- sous forme récursive sans troncature, donc sans perte de qualité de filtrage
f
1
n x(n) f (n) y (n)
Prenons l’exemple du filtre RII f (n) : 0
Y ( z) 1
f ( n ) = Γ ( n) →
TZ
F ( z) = =
X ( z ) 1 − z −1
- forme non récursive :

f
1
0 n
Troncature de f (n) sur 3 pixels par exemple : 0 1 1
0 1* 1
→ masque : * : pixel d'application du masque → algorithme : y (n) = x(n) + x(n + 1) algorithme non récursif
Normalisation du filtre :
Il faut en outre normaliser le filtre pour que l’image résultat du traitement ait la même dynamique que l’image
initiale (pour ainsi autoriser un affichage simplifié) : la somme des poids du masque doit être égale à 1. D’où le masque
normalisé :
0 0.5* 0.5
→ masque normalisé : * : pixel d'application du masque → algorithme non récursif : y (n) = 0.5 x(n) + 0.5 x(n + 1)
- forme récursive :
Y ( z) 1 −1
= −1
→ Y ( z ) − z Y ( z ) = X ( z ) → y ( n) = y ( n − 1) + x ( n) algorithme récursif
X ( z) 1 − z
Normalisation du filtre :
Il faut en outre normaliser le filtre pour que l’image résultat du traitement ait la même dynamique que l’image
∞
1
initiale : ∑ f ( n) = 1
n = −∞
soit sur une image dont la largeur est de taille nx : f (n) =
nx
Γ ( n)
1 Y ( z) 1 1 −1 1
f ( n) = Γ ( n) →
TZ
F ( z) = = → Y ( z) − z Y ( z) = X ( z)
nx X ( z ) nx 1 − z −1 nx
→ algorithme récursif : y ( n) =
1
[ y(n − 1) + x(n)]
nx
3 Annexe. 7
−α n
Application au filtre dérivateur de Deriche de RI f (n) : f (n) = Sne
f
n ∞
x(n) f (n) y (n)
y ( n) = x ( n) * f ( n ) = ∑ x(k ) f (n − k )
k = −∞
Comme f (n) est RII, pour implémenter le filtre f (n) , on a 2 solutions :
f tronquée
K n
- tronquer le filtre f (n) : → y ( n) = ∑ x(k ) f (n − k )

k =− K
( y (n) non récursif) →
- calculer la TZ de f (n) → y (n) programé de façon non récursive (choix de Deriche) pour ne pas perdre de
Y ( z) z 1 −1
précision à cause de la troncature : → = F ( z) ≈ = → Y ( z )[1 − az ] = X ( z )
X ( z) z − a 1 − az −1
→ y ( n) = x (n) + ay ( n − 1) ( y (n) récursif)

Critère optimal de Canny :
Nouvelle tendance en détection des contours: elle pose le problème en ces termes.
Etant donné un modèle du contour recherché :
escalier rampe pointe toit
et le type de l'opération détection (dérivation du 1er ordre, du 2ème ordre...), quel est l'opérateur optimal suivant certains
critères (maximisation de Σ (rapport Signal/Bruit : S/B), de Λ (localisation) et de ∆ (unicité de la réponse)...) qui permet
la détection de ce modèle dans un contexte donné (bruit additif blanc gaussien, ...).
Critère de Canny :
- modèle de contour = (escalier ou saut)
- type de détection = gradient par un filtre RII
- 3 critères de performances = Σ, Λ, ∆
- détection = recherche des maximas de la norme du gradient
- contexte = bruit blanc gaussien additif
Filtre de Deriche :
Deriche a recherché l'opérateur détecteur (≡ dérivateur) optimal sous la forme d'un filtre RII de RI f(x) de la forme :
f ( x ) =S .x.e
−α x
filtre 1D détecteur (dérivateur) de Deriche
avec: S: constante de normalisation et α: paramètre du filtre.

(S<0 pour que la RI ait l'allure voulue, permettant la détection (convolution maximale à l'endroit de la transition).
Entrée 1D e(x) (saut bruité)
0 x
Détecteur f(x)
0
x
Sortie : f(x) * e(x)
x
0
3 Annexe. 8
- le filtre est bien sûr discrétisé, ( f(x) → f(n) avec n: discret [n=mT avec m entier et T réel (période d'échantillonage)
pris à 1 ici → T "égal" à la résolution de l'image] et f(n) à valeurs discrètes ), et il est mis en oeuvre de façon récursive
pour éviter les erreurs de troncature du filtre.
- la séquence discrète h(n) de l'intégrale continue h(x) de f(x) est utilisée comme RII de la fonction de lissage préalable
avant la détection :
h(n ) =k .(α n + 1).e
−α n
filtre 1D de lissage de Deriche
avec : k : constante de normalisation.
- Normalisation :
∞ 0
f (n) : ∑ f (n ) = − ∑ f (n ) = −1
n =0 n = −∞
∞
on a : ∑ f (n ) = − 1
n =0
et non 1, car f(n) < 0 pour n > 0.
∞
on a bien : ∑ f (n ) =0
n = −∞
car f(n) est un dérivateur (∑poids du masque = 0).
∞
h(n) : ∑ h(n) = 1
n = −∞
le filtre h(n) est un filtre de lissage : ∑poids du masque = 1, pour garder la même dynamique qu'avant filtrage.
- Algorithme :
1. lissage en y * dérivation en x → gradient récursif en x : Gx (* : convolution)

2. lissage en x * dérivation en y → gradient en y : Gy
3. gradient :
norme: G == + Gx 2 + Gy 2 direction : D = Arctg (Gy / Gx )
4. suppression des non maximas locaux du gradient.
5. seuillage de la norme du gradient pour donner les contours.
(le lissage et la dérivation étant linéaires et la convolution étant commutative, on peut appliquer les deux opérations dans
un ordre indifférent,).
Filtre dérivateur discret f(n) :
f ( x ) = S. x . e−α x continu → f ( n ) = S . n . e − α n discret

f(n)
0 n
3 Annexe. 9
Soit : x(n) le signal d'entrée 1D (saut bruité).

−α n
f(n) le filtre détecteur (dérivateur) 1D : f (n) = S ne
∞
y(n) la sortie du filtre détecteur 1D. On a: y ( n ) = f ( n ) ∗ x ( n )= ∑ f (k ) x(n − k )
k = −∞
soit : f − (n) = f (n) pour n < 0 et : f + (n) = f (n) pour n > 0

−1 +∞
soit : y − ( n) = ∑
k = −∞
f ( k ) x (n − k ) et : y + ( n) = ∑ f ( k ) x( n − k )
k =1
on a: y ( n ) = y − ( n ) + y + ( n ) + f ( 0) x ( n ) = y − ( n ) + y + ( n ) car : f ( 0) = 0
+∞
Calculons la Transformée en z (TZ) Y(z) de y(n) : ( rappel : Y ( z) = ∑ y ( n) z
n = −∞
−n
)
[ ]
−1
y − ( n) = ∑ f (k ) x(n − k ) → Y
k = −∞
TZ −
( z ) = F − ( z ) X ( z ) avec : F − ( z ) = TZ f − (n)
[ ]
∞
y + (n) = ∑ f (k ) x(n − k ) →
TZ
Y + ( z) = F + ( z) X ( z) avec : F + ( z ) = TZ f + (n)
k =1
1 si n ≥ 0
Calcul de : [ ]
F + ( z ) = TZ f + (n) = TZ Sne −αn Γ(n − 1) [ ] avec : Γ ( n) =
0 si n < 0
Posons: a = e - α ; on a, d'après les tables : TZ a n Γ(n) = [ ] z

z−a
n −1
→ TZ a Γ( n − 1) = [
1
z−a
]
en utilisant la propriété de la TZ: TZ [ f (n − k )] = z − k ⋅ TZ [ f (n)]
D'où : [
TZ a n Γ(n − 1) = ] a
z−a
.
TZ [n ⋅ f (n)] = − z ⋅
{TZ [ f (n)]} on a:
d
D'après la propriété :
dz
[
TZ na n Γ(n − 1) = − z
d
]
dz
{ [
TZ a n Γ(n − 1) =
az
( z − a) 2
]}
+ Se −α z
d'où : F ( z ) =
( z − e −α ) 2
Calcul de : [ ]
F − ( z ) = TZ f − (n) = TZ Sneαn Γ(−n − 1) [ ]
Posons : a = eα .
Effectuons un changement de variable, les tables n'étant données que pour les signaux causaux:
−1 −1 −n n
d −1  z  d ∞ z d  z 
−
F ( z) = ∑f
n = −∞
−
(n)z −n
= ∑ Sna
n = −∞
n
z −n
= − Sz ∑ 
dz n = −∞  a 
= − Sz ∑   = − Sz 
dz n =1  a 

dz  a − z 
eα
d'où : F − ( z ) = − Sz
(e α − z ) 2
3 Annexe. 10
Implémentation récursive de f(n) par utilisation de la TZ :
Calcul de : y + (n)
e −α zX ( z )
Y + ( z) = F + ( z) X ( z) = S → Y + ( z ).( z − e −α ) 2 = Se −α zX ( z )
( z − e −α ) 2
→ z 2Y + ( z ) − 2e −α zY + ( z ) + e −2α Y + ( z ) = Se −α zX ( z )
→ Y + ( z ) − 2e −α z −1Y + ( z ) + e −2α z −2Y + ( z ) = Se −α z −1 X ( z ) en divisant les 2 membres par z 2 .
TZ TZ
Du fait que si: x ( n) → X ( z ) , on a d'après le théorème du retard: x(n − k ) → z −k . X ( z )
d'où, par TZ −1 (formulation causale) : y + (n) = Se −α x(n − 1) + 2e −α y + (n − 1) − e −2α y + (n − 2)

a = Se −α
Soit : y + (n) = ax(n − 1) − b1 y + (n − 1) − b2 y + (n − 2) avec : b1 = −2e −α
b2 = e − 2α
Calcul de : y − (n)
eα zX ( z )
Y − ( z) = F − ( z) X ( z) = −S → Y − ( z ).(eα − z ) 2 = − Seα zX ( z )
(e α − z ) 2
→ e 2α Y − ( z ) − 2eα zY − ( z ) + z 2Y − ( z ) = − Seα zX ( z )
→ Y − ( z ) − 2e −α zY − ( z ) + e −2α z 2Y − ( z ) = Se −α zX ( z ) en divisant les 2 membres par e 2α .
d'où, par formulation non causale: y − (n) = Se −α x(n + 1) + 2e −α y − (n + 1) − e −2α y − (n + 2)

a = Se −α
Soit : y − (n) = ax(n + 1) − b1 y − (n + 1) − b2 y − (n + 2) avec toujours : b1 = −2e −α
b2 = e − 2α
Normalisation du filtre dérivateur f(n) :

∞ ∞ ∞ ∞
∑
n =0
f (n) = −1→∑ Sne −αn = −1 → − S −1 = ∑ ne −αn = b∑ nb n −1
n=0 n =0 n =0
avec : b = e
−α
∞ ∞
d (b n ) d ∞ d  1  b
or : b∑ nb n −1 = b∑ = b ∑ bn = b  =
n =0 n =0 db db n=0 db  1 − b  (1 − b) 2
(1 − b) 2 (1 − e −α ) 2
d'où : S = − =−
b e −α
3 Annexe. 11
Récapitulation : filtre dérivateur f(n) :
entrée 1D x(n) (saut bruité) détecteur f(x) sortie y(n) = f(n) * x(n)
gradient
n 0 n
0 n
0
−α n
avec: f (n) = Sne
Soit N le nombre de points d'une ligne d'image et 1, l'indice du 1er élément des vecteurs y+, y- et x :
 y + (n) = ax(n − 1) − b1 y + (n − 1) − b2 y + (n − 2) pour : n ="1" → N (balayage gauche → droite)

 − − −
 y (n) = ax(n + 1) − b1 y (n + 1) − b2 y (n + 2) pour : n =" N " → 1 (balayage droite → gauche)
 − +
 y (n) = y (n) + y (n) pour : n = 1 → N N points (1 ligne d' image = N points)
(1 − e −α ) 2
e −α 1 2
Remarque:
On note par exemple: n= "1"→N à cause de l'effet de bord: en fait on devrait écrire plus précisément: n= 3→N dans ce
cas de figure.
x(n) y(n) = f(n)*x(n) y − ( n) = y ( n ) pour n<0

f(n) + +
-
y(n) = y (n) + y (n) avec : y (n) = y (n) pour n > 0
y ( 0) = 0
Nombre d'opérations par point du filtre dérivateur :
11 opérations par point (6x et 5+), alors que l'implémentation non récursive :
∞ troncature
y ( n) = ∑ f ( n − k ) x ( k )
k = −∞
= ∑ f (n − k ) x(k )
M points
requiert: 2M-1 opérations par point ( Mx et (M-1)+ )
à comparer aussi avec les 17 opérations par point (9x et 8+) que prendrait l'application de la convolution avec un masque
3x3.
3 Annexe. 12
Filtre de lissage discret h(n) :
h(n) est la discrétisation de l'intégrale h(x) de la fonction de dérivation f(x) :

−α n
h(n) = K .(α n + 1).e
(la constante K est fixée par normalisation).
h(n)
n
0
x0 + x dh( x)
On a : h(n) =
h( x) ∫
= x0
f (u )du
→
f ( x ) =
dx
x=n x=n
f ( n) = f ( x = n)
Vérification (pour x>0) :
h( x) = K (αx + 1)e −αx

dh( x)
dx
= K αe −αx − α (αx + 1)e −αx
→ f ( x) = [ ]
−αx 2
[ 2
]
f ( x) = Ke α − α x − α = − Kα xe −αx → f (n) = Sne −αn (n > 0) avec : S = − Kα
2
−α n
d'où : f (n) = Sne ∀n entier
Lissage :
x(n) y(n) = h(n)*x(n)

h(n)
Soit : x(n) le signal d'entrée.

−α n
h(n) le filtre de lissage 1D : h(n) = K .(α n + 1).e
∞
y(n) la sortie du filtre de lissage 1D. On a: y ( n ) = h ( n ) ∗ x ( n )= ∑ h( k ) x( n − k )
k = −∞
soit : h − ( n) = h ( n ) pour n < 0 et : h + ( n) = h( n ) pour n ≥ 0
−1 +∞
soit : y − ( n) = ∑ h( k ) x ( n − k )
k = −∞
et : y + ( n) = ∑ h( k ) x ( n − k )
k =0
on a: y ( n ) = y − ( n) + y + ( n )
3 Annexe. 13
+∞
Calculons la Transformée en z (TZ) Y(z) de y(n) : ( rappel : Y ( z) = ∑ y ( n) z
n = −∞
−n
)
[ ]
−1
y − ( n) = ∑ h( k ) x ( n − k )
k = −∞
→
TZ
Y − ( z ) = H − ( z ) X ( z ) avec : H − ( z ) = TZ h − (n)
[ ]
∞
y + ( n) = ∑ h( k ) x( n − k ) →
TZ
Y + ( z) = H + ( z) X ( z) +
avec : H ( z ) = TZ h ( n)
+
k =0
1 si n ≥ 0
Calcul de : [ ] [
H + ( z ) = TZ h + (n) = TZ K (αn + 1)e −αn Γ(n) ] avec : Γ( n) =
0 si n < 0
a = e - α ; on a, d'après les tables : TZ a n Γ(n) =

z
Posons :
  z − a
et, d'après la propriété de la TZ : TZ  na Γ( n)  = − z


n

d
dz
[
TZ (a n Γ(n) =
az
( z − a) 2
]
+ Kαaz Kz −α
d'où : H ( z ) = + avec : a = e
( z − a) 2
z−a
Calcul de : [ ] [
H − ( z ) = TZ h − (n) = TZ K (1 − αn)eαn Γ(− n − 1) ]
Posons : a = e−α .
Effectuons un changement de variable, les tables de Transformées en Z n'étant données que pour les signaux causaux :
−1 −1 ∞ ∞
H − ( z) = ∑h
n = −∞
−
(n)z −n = ∑ K (1 − αn)eα z
n = −∞
n −n
= K ∑ a n z n + Kα ∑ na n z n
n =1 n =1
az az −α
d'où : H − ( z) = K + Kα avec : a = e
1 − az (1 − az ) 2
3 Annexe. 14
Implémentation récursive de h(n) par utilisation de la TZ :
Calcul de : y + (n)
 αe − α z z 
Y + ( z) = H + ( z) X ( z) =  K −α 2
+K −α 
X ( z ) → Y + ( z ).( z − e −α ) 2 = Kαe −α zX ( z ) + Kz ( z − e −α ) X ( z )
 (z − e ) z−e 
d'où, en divisant les 2 membres de l'équation par z2 et après TZ −1 (formulation causale) :

a0 = K
a1 = K (α − 1)e −α
y + (n) = a 0 x(n) + a1 x(n − 1) − b1 y + (n − 1) − b2 y + (n − 2) avec :
b1 = −2e −α
b2 = e −2α
Calcul de : y − (n)
 e −α z αe −α z 
Y − ( z) = H − ( z) X ( z) = K −α
+ K −α 2 
X ( z ) → Y − ( z ).(1 − e −α z ) 2 = Ke −α z (1 − e −α z ) X ( z ) + Kαe −α zX ( z )
 1− e z (1 − e z ) 
d'où, par TZ −1 avec une formulation non causale :

a 2 = Ke −α (1 + α ) = a1 − Kb1
− − −
a3 = − Ke −2α = − Kb2
y (n) = a 2 x(n + 1) + a3 x(n + 2) − b1 y (n + 1) − b2 y (n + 2) avec :
b1 = −2e −α
b2 = e −2α
Normalisation du filtre de lissage h(n) :
∞ −1 ∞ ∞
 
∑ h(n) = 1 →
n =−∞
∑[
n =−∞
] n =1
[  n =1
]
K (1 − α n) eα n + K + ∑ K (α n + 1) e −α n = K 1 + 2∑ (α n + 1) e −α n 

or :
∞
d (∑ e −αn )
∞ ∞ ∞
e −α e −α − e − 2α + αe −α
∑ (αn + 1)e
n =1
−αn
=e −α
∑ (e
n =0
−α
) + αe
n −α
∑ n( e
n =1
−α
) n −1
=
1− e −α
+ αe −α n =1
de −α
=
(1 − e −α ) 2
(1 − e −α ) 2
d'où : K =
1 + 2αe −α − e −2α
3 Annexe. 15
Récapitulation : filtre de lissage h(n) :
entrée 1D x(n) (saut bruité) lissage h(n) sortie y(n) = h(n) * x(n)
0 n n n
0 0 avec:
−α n
h(n) = K .(α n + 1).e
 y + ( n) = a 0 x(n) + a1 x( n − 1) − b1 y + ( n − 1) − b2 y + ( n − 2) pour : n ="1" → N

 − − −
 y ( n) = a 2 x(n + 1) + a 3 x(n + 2) − b1 y ( n + 1) − b2 y ( n + 2) pour : n =" N " → 1
 − +
 y (n) = y ( n) + y (n) pour : n = 1 → N N points (1 ligne d' image = N points)
avec :
(1 − e −α ) 2
K= ; a0 = K ; a = K (α − 1)e − α ; b = −2e − α ; b = e − 2α ;
1 + 2αe −α − e −2α 1 1 2
a 2 = a1 − Kb1 ; a3 = − Kb2 .
x(n) y(n) = h(n)*x(n)

h(n) y − ( n) = y ( n) pour n < 0
y(n) = y - (n) + y + (n) avec : +
y (n) = y (n) pour n ≥ 0
Nombre d'opérations par point du filtre de lissage :
15 opérations par point (8x et 7+), alors que l'implémentation non récursive :
∞ troncature
y ( n) = ∑ h ( n − k ) x ( k )
k = −∞
= ∑ h( n − k ) x ( k )
M points
requiert: 2M-1 opérations par point ( Mx et (M-1)+ ).
3 Annexe. 16
Implémentation 2D du filtre de Deriche (dérivation f(n) et lissage h(n) :
Soit G (gradient lissé) : le filtre constitué de l'ensemble lissage h(n) et dérivation f(n).
Séparation du filtre G : (But : réduction du coût en temps calcul)
G2D = f2D* h2D * IM IM : Image initiale; G2D: Image gradient lissé.
Avec le choix : G2D= Gx+Gy , on a :
G2D (= Gx +Gy) = (fx +fy) * (hx + hy) * IM
= [( )
f x * hx + hy * IM ] + [( )
f y * hx + hy * IM ]
←→ ←→
Gx Gy
= ( f x * IM ) * (hx + h y ) + ( f y * IM ) * (h x + h y )
←→ ←→
Gx Gy
la convolution étant commutative et associative.
Deriche fait le choix suivant, du fait de la redondance dans l'application en x et en y du filtre h :
Gx = ( f x * IM ) * hy Gx = ( f x * IM ) * ( hx + hy )
et non pas :
G y = ( f y * IM ) * hx
: chacun des 2 opérateurs f et h est bien appliqué à la fois en x et en y.
G2 D = G + G 2
x
2
y
: le calcul du gradient est réalisé en réel.
Remarque : on a le même résultat avec le choix, par exemple pour Gx : (

Gx = hy * IM * f x)
3 Annexe. 17
Algorithme du filtre de Deriche : (Préambule)
On a vu :
−α n
Equations du filtre dérivateur 1D f(n) : f (n) = Sne
 y + (n) = x (n − 1) − b1 y + (n − 1) − b2 y + ( n − 2) pour : n ="1" → N

 − − −
 y (n) = x( n + 1) − b1 y ( n + 1) − b2 y ( n + 2) pour : n =" N " → 1

{ + −
 y ( n) = a y ( n) − y ( n) } pour : n = 1 → N N points (1 ligne d' image = N points)
(1 − e −α ) 2
e −α 1 2
−α n
Equations du filtre de lissage 1D h(n) : h(n) = K .(α n + 1).e
 y + ( n) = a 0 x( n) + a1 x( n − 1) − b1 y + ( n − 1) − b2 y + (n − 2) pour : n ="1" → N
 − − −
 y ( n) = a 2 x( n + 1) + a 3 x( n + 2) − b1 y (n + 1) − b2 y ( n + 2) pour : n =" N " → 1
 + −
 y (n) = y (n) + y ( n) pour : n = 1 → N N points (1 ligne d' image = N points)
avec :
(1 − e −α ) 2
K=
a0 = K a = K (α − 1)e − α b = −2e − α b = e − 2α
1 + 2αe −α − e − 2α ; ; 1 ; 1 ; 2 ;
a 2 = a1 − Kb1 ; a3 = − Kb2
.
On en déduit l'algorithme du filtre de Deriche 2D :
3 Annexe. 18
Algorithme du filtre de Deriche :
1. Calcul récursif du gradient lissé en x : Gx(x,y) :

Gx = (fx * IM) * hy = S * hy en posant : S = fx * IM IM: image initiale de taille Nx*Ny
1a. Calcul de S = fx * IM : (S :temporaire) S = fx * IM (→ et ← )
 +  x ="1" → N x 
S ( x, y ) = IM ( x − 1, y ) − b1S ( x − 1, y ) − b2 S ( x − 2, y )
+ +
y = 1 → N 
  y 

 −  x =" N x " → 1
S ( x, y ) = IM ( x + 1, y ) − b1S ( x + 1, y ) − b2 S ( x + 2, y )
− −
y = → N 
  1 y 

x = 1 → N x 
{ }
S(x, y ) = a S + ( x, y ) − S − ( x, y )
 y = 1→ N 
 y
1b. Caclul de Gx = S * hy : Gx = S * hy (↓ et ↑ )
 + x :1 → N x 
G ( x, y ) = a 0 S( x, y ) + a1S( x, y - 1) − b1G ( x, y − 1) − b2 G ( x, y − 2 )
+ +
 y :"1" → N 
  y

 − x :1 → N x 
G ( x, y ) = a 2 S( x, y + 1) + a3 S( x, y + 2 ) − b1G ( x, y + 1) − b2 G ( x, y + 2 )
− −
 y :" N " → 1
  y 

G ( x, y ) = G − ( x, y ) + G + ( x, y ) x = 1 → N x 
 x y = 1→ N 
 y
2. Calcul récursif du gradient lissé en y : Gy(x,y) :

Gy = (fy * IM) * hx = S * hx en posant : S = fy * IM
2a. Calcul de S = fy * IM : (S : temporaire) S = fy * IM (↓ et ↓ )
 + x = 1 → N x 
S ( x, y ) = IM ( x, y − 1) − b1S ( x, y − 1) − b2 S ( x, y − 2 )
+ +
 y ="1" → N 
  y

 − x = 1 → N x 
S ( x, y ) = IM ( x, y + 1) − b1S ( x, y + 1) − b2 S ( x, y + 2 )
− −
 y =" N " → 1
  y 

x = 1 → N x 
{ }
S(x, y ) = a S + ( x, y ) − S − ( x, y )
 y = 1 → N 
 y
2b. Calcul de Gy = S * hx Gy = S * hx (→ et ← )
 +  x ="1" → N x 
G ( x, y ) = a 0 S( x, y ) + a1S( x − 1, y ) − b1G ( x − 1, y ) − b2 G ( x − 2, y )
+ +
y = 1→ N 
  y 

 −  x =" N " x → 1
G ( x, y ) = a 2 S( x + 1, y ) + a 3 S( x + 2, y ) − b1G ( x + 1, y ) − b2 G ( x + 2, y )
− −
y = 1→ N 
  y 
 x = 1 → N x 
G ( x, y ) = G − ( x, y ) + G + ( x, y )
 y y = 1→ N 
 y
3 Annexe. 19
3. Calcul de la norme et de la direction du gradient : G(x,y) et D(x,y):
G(x,y) = G x2 ( x, y ) + G y2 ( x, y ) : norme du gradient.
 G y ( x, y ) 
D( x, y ) = Arctg  
( )
: direction du gradient.
G
 x x , y 
4. Suppression des non maximas locaux de la norme du gradient :
Elimination des non maximas locaux de la norme du gradient dans la direction du gradient.
5. Seuillage de l'image de la norme des gradients :
Sélection des points de l'image « norme des gradients » comme points de contours si la valeur v de leur norme du
gradient est telle que : v > Seuil.
→ l'image des contours est alors obtenue.
Application des critères de performances sur l'opérateur dérivateur f(x) de Deriche :
Appliquons les 3 critères de performances précédemment définis à la partie dérivateur, sous sa forme continue, de
l'opérateur de Deriche sous sa forme 1D, et faisons apparaître sa supériorité par rapport à celui de Sobel :
−α x
RI continue : f ( x) = Sxe
1- Détection :
En remplaçant f(x) caractérisant le filtre, dans l'expression Σ d'origine donnant le rapport Signal sur Bruit (S/B), on obtient :
f ( x )dx
0 0
∫ ∫ x.eαx dx
1 − 1/ α
2
−∞ 1 −∞
Σ= = = = 2 /α
+∞
α
∫ f (x )dx
0 3
2 2 2αx 2
−∞ ∫
−∞
x .e dx 1 / 4
en utilisant les relations donnant les primitives :
e ax 1 e ax x 2
∫ x ⋅ e dx = a ( x − a ) ∫ x ⋅ e dx = a ( x − 2 a + a 2 )
ax 2 ax 2
et
Le rapport (S/B) en sortie du filtre de Deriche a donc pour expression :
A
S/B= 2 /α .
n0
Il décroit avec α, et pour une valeur typique de α égale à un, il est supérieur au rapport signal sur bruit à l'entrée du
filtre, le rapport Σ étant supérieur à un :
Σ ≅ 1.41 pour α = 1.
3 Annexe. 20
2- Localisation :
f ′( x ) = S .e .(1 − α x )
−α x
D'après l'expression de la dérivée f(x) de la RI :
e ax
∫ e dx =
ax
et, en utilisant la relation :
a
ainsi que les primitives du même type déjà rencontrées, on obtient une localisaation dont la précision croît avec le
paramètre α :
f ′(0) S
Λ= = = 2α ≅ 1.41 pour α = 1.
+∞
f ′ ( x )dx S / 2α
∫
2
−∞
3- Unicité de la réponse :
La dérivée seconde de la RI f(x) a pour expression :
 f ′′( x ) = Sx.e −αx .(αx − 2 ) pour x ≥ 0


 f ′′( x ) = Sx.e −αx .(αx + 2 ) pour x ≤ 0
et en utilisant les primitives déjà décrites ainsi que les résultats fournis par la calcul de la localisation, on a :
+∞
∫ f ′′ 2 ( x )dx S .α . 5 / 2α
∆= −∞
= = α . 5 ≅ 2.24 pour α = 1.
+∞
f ′ ( x )dx S / 2α
∫
2
−∞
dont la qualité croît avec α.
3 Annexe. 21
Comparatif des résultats des opérateurs de Deriche et de Sobel aux 3 critères :
Détection : Σ
Deriche : Σ = 2 /α _____________ 1.41 (α = 1.)
Sobel : Σ = 1/ 2 _______ 0.71
Localisation : Λ
Deriche : Λ = 2α _____________ 1.41 (α = 1.)
Sobel : Λ = 1/ 2 ______ 0.5
Unicité de la réponse : ∆
Deriche : ∆ =α 5 __________________ 2.24 (α = 1.)
Sobel : ∆ = 10 / 2 _______________ 1.58
Deriche (α = 1.) : Sobel :

Σ Σ
Λ Λ
∆ ∆
__________
3 Annexe. 22
Traitement d'images 6 Annexe. Introduction à la Reconnaissance Des Formes
6 ANNEXE. Introduction à la Reconnaissance Des Formes (RDF)
1. Reconnaissance d'objets même partiellement cachés

Analyse des méthodes de reconnaissance en vision par ordinateur
1.1. Introduction
Limitation de l’univers - Objets entièrement visibles et objets en partie cachés
La représentation d'une image sous forme de contours segmentés permet d'envisager l'identification des objets présents
dans la scène. Il est nécessaire de passer par une phase d'apprentissage et de modélisation de ces objets en faisant
intervenir des caractéristiques discriminantes. La reconnaissance consiste alors à rechercher de telles caractéristiques
dans l'image et les mettre en correspondance avec celles des modèles.
On peut distinguer deux types d'approches pour la modélisation et l'identification selon que les objets dans la scène
apparaissent entièrement visibles ou en partie cachés.
Dans la première hypothèse, on peut mettre en évidence des caractéristiques globales du fait que la totalité de l'objet à
identifier est apparente.
Pour des objets en partie cachés, les modèles ne peuvent que s'appuyer sur des caractéristiques locales et des formes
géométriques élémentaires pour représenter toute portion d'un objet.
1.2. Les différents méthodes
1.2.1. Reconnaissance d'objets isolés
Pour des images contenant des objets isolés, on peut caractériser chacun d'eux de façon globale. Le périmètre par
exemple, la surface, la variation de la courbure en fonction de l'abcisse curviligne peuvent être utilisés.
Rives utilise le barycentre et met en évidence les points d'intersection avec un cercle centré sur ce dernier.
D'autres caractéristiques telles que le rapport du périmètre sur la surface (finesse), le rapport des axes principaux
d'inertie, le plus petit cercle incluant le contour, le plus grand cercle inscrit... peuvent également être utilisées, les
caractéristiques les plus intéressantes étant celles qui sont invariantes par translation et par rotation.
L'apprentissage d'un objet se résume à sa représentation par un ensemble de caractéristiques (un vecteur) discriminantes.
En réalité, malgrè le fait que les caractéristiques soient stables pour toutes les configurations de l'objet dans le
plan (rotation et translation), des différences peuvent apparaître du fait du bruit apporté à chaque étape du traitement
(numérisation, détection des contours...).
Dans la pratique,on associe à chaque classe plusieurs vecteurs correpondant à des positions différentes du même objet.
L'étape de reconnaissance consiste alors à trouver la classe à laquelle appartient un vecteur calculé sur l'image. On a
affaire à un problème classique de Reconnaissance Des Formes pour lequel de nombreuses méthodes ont été élaborées.
Une première catégorie de méthodes regroupe celles dites paramétriques ou « Bayesiennes ».

La répartition des différents vecteurs dans une même classe est régi suivant une densité de probabilité telle que les
fonctions gaussiennes. La classification d'une forme inconnue F dans une classe Ci obéit à une loi Bayesienne :
p(F/Ci). p(Ci) > p(F/Cm). p(Cm) ∀m≠i
où p(F/Cm) représente la densité de probabilité de F connaissant la classe Cm et p(Cm) la probabilité de la classe Cm.
Ces fonctions et valeurs sont évaluées dans la phase d'apprentissage pour modéliser les différentes classes de formes.
6 Annexe. 1
Une seconde catégorie comprend les méthodes non paramétriques.

- les k plus proches voisins
On peut par exemple, dans la phase d'apprentissage, modéliser chaque classe par un ensemble de vecteurs et rechercher
les « k plus proches voisins » du vecteur à identifier dans la phase de reconnaissance. Celui-ci est alors affecté dans la
classe la plus représentée parmi les k vecteurs.
Des versions rapides ont été développées , mais la méthode reste tout de même couteûse en temps calcul.
L'utilisation d'arbres de décision constitue une alternative intéressante. On fait intervenir successivement dans l'ordre le
plus discriminant, les différentes composantes du vecteur et on restreint à chaque recherche le nombre de classes
possibles.
On crée ainsi un arbre dont les noeuds sont représentés par les composantes du vecteur.
Les différents chemins élaborés à partir d'un noeud dépend de la composante en ce noeud et chaque feuille terminale
représente une classe unique.
L'étape de la reconnaissance se ramène à un parcours de l'arbre suivant les caractéristiques du vecteur à classer. Moins
couteûses en temps calcul, ces méthodes nécessitent des tests robustes ou mieux, des parcours en sens inverse de l'arbre
pour éviter qu'une erreur à un quelconque niveau n'entraîne irrémédiablement une mauvaise classification.
La localisation d'un objet, faisant suite à sa reconnaissance, peut se faire par la mise en correspondance de points
remarquables de l'objet dans l'image et de son modèle.
De telles méthodes sont séduisantes par la facilité de leur mise en oeuvre, mais elles sont limitées lorsque le nombre de
modèles devient grand ou lorsque les contours segmentés sont très bruités (présence d'ombres, de reflets, objets se
chevauchant...).
Reconnaissance d'objets partiellement visibles (autres méthodes de RDF) :
Dès lors que les objets à identifier sont en partie cachés, il est préférable d'utiliser des primitives locales pour décrire la
scène et les modèles.
Dans le cas d'une image pour laquelle l'échelle par rapport aux modèles n'est pas à priori connue, ces primitives sont
limitées et correspondent à des points remarquables (angles, points de courbure maximales...) ou à des figures
géométriques de base (segments de droite, arcs de cercle ou d'ellipse, parallèlogramme...).
Dans le cas contraire où l'échelle est connue, des primitives plus complexes peuvent être recherchées comme chaînage
de plusieurs primitives simples.
La scène et les modèles sont décrits à partir de ces primitives locales et de leurs positions relatives. L'étape de
reconnaissance doit faire une mise en correspondance des primitives de la scène avec celles des modèles en respectant
leurs positions relatives.
1.2.2. Les méthodes corrélatives
Elles utilisent la représentation des contours segmentés dans un espace à deux dimensions et, à l'aide d'une fonction de
corrélation, elles évaluent dans cet espace la similitude entre différentes portions des contours de la scène et du modèle.
Perkins utilise cette méthode et propose d'approximer les lignes de contour par des chaînages de segments de droite et
d'arcs de cercles appelés « polylignes ». Il classifie ensuite par ordre de vraisemblance tous les appariements possibles
entre polylignes de la scène et du modèle, au regard de la nature des primitives constituant les polylignes et de leurs
paramètres (longueur, courbure...)
6 Annexe. 2
Ce processus combinatoire implique un nombre de mise en correspondance limité du fait que le nombre de polylignes
est restreint dans une scène donnée.
Les correspondances sont analysées par vraisemblance décroissante jusqu'à obtenir la transformation permettant de
passer d'une partie des contours du modèle à ceux de la scène.
Cette analyse comprend deux phases :
- la première effectue une représentation du couple de polylignes appariées dans l'espace formé par l'abcisse curviligne
et l'orientation de la tangente aux contours, fonction de l'abcisse curviligne;
- la seconde utilise une fonction de corrélation et fait glisser l'une sur l'autre chacune des deux représentations du couple
de polylignes appariées pour en faire la meilleure mise en correspondance locale.
Ces mises en correspondance renseignent sur la transformation recherchée. Une vérification est entreprise, lorsque la
transformation trouvée est complètement définie grâce à un nombre suffisant de couples de polylignes, en appliquant
cette transformation au modèle complet et en évaluant le pourcentage de superpositions d'un échantillon de points du
modèle avec l'objet à identifier.
Riad choisit d'appliquer les corrélations à des primitives de longueur fixe. Pendant l'apprentissage, des contours de
longueur donnée les plus discriminants par rapport à la forme des autres objets à reconnaître sont recherchés. On fait
correspondre à chaque primitive sélectionnée un ensemble des différents modèles qui l'incluent dans leurs contours.
Chaque modèle est ensuite représenté par un ensemble de ces primitives et de leurs positions respectives.
Pendant la phase de reconnaissance, la recherche et la localisation d'une primitive dans l'image utilise une fonction de
corrélation appliquée sur les codes de Freeman étendus, compensés et lissés des contours de l'image et de la primitive.
Un arbre de décision est construit dans l'étape d'apprentissage qui après chaque primitive détectée fait tendre cers la
suivante à trouver pour aller vers un modèle donné.
Ces prédictions sont vérifiés par la fonction de corrélation. Une fois un modèle complètement décrit, on réitère le
processus pour les autres contours de l'image.
1.2.3. Les méthodes des cliques maximales
Ces méthodes utilisent un graphe dont les noeuds représentent tous les appariements possibles entre une primitive de la
scène et du modèle.
Ces primitives, qui regroupent des caractéristiques locales du contour des objets, sont classés en différents types (angles
droits, lacunes isolées...) à l'intérieur desquels les appariements sont réalisés.
Les arcs du graphe témoignent de la compatibilité des positions relatives des deux primitives de la scène, associées
chacune à un noeud, avec celles des modèles qui leur sont appariés.
A partir du graphe, les « cliques maximales » sont recherchées, c'est à dire les plus grands sous-ensembles de noeuds
reliés deux à deux, car ils correpondent aux groupes de primitives les plus importants dans la scène dont les positions
sont correctes entre elles et vis à vis du modèle.
On peut alors localiser l'objet à identifier dans la scène et vérifier cette localisation par superposition des contours du
modèle dans la scène.
Le nombre de primitives croissant entraîne cependant une importante complexité du graphe rendant son traitement
relativement lourd, et on peut se restreindre à des sous-graphes locaux.
A cet effet, dans la phase d'apprentissage les primitives de chacun des modèles sont partitionnées en sous-groupes de
façon la plus directement discriminante possible.
Dans chaque sous-groupe les primitives sonr indexées par rapport à une primitive principale, et un coût de détection et
de vérification est calculé pour tout le sous-groupe.
6 Annexe. 3
Dans la phase de reconnaissance, le sous-groupe de plus faible coût correspondant au modèle à identifier est recherché.
On sélectionne alors les primitives de la scène de même type que la primitive principale, ainsi que leurs voisines qui
correspondent en type et en distance aux autres primitives de ce sous-groupe. Le graphe témoigne ainsi des
combinaisons possibles entre les primitives de la scène et celles du sous-groupe.
Une clique maximale reflète la position du sous-groupe et donc du modèle.
Des prédictions-vérifications sur les autres primitives du modèle viennent l'appuyer, et des points de son contour
vérifient sa présence effective.
1.2.4. Les méthodes de relaxation d'étiquetage
Les techniques de relaxation d'étiquetage probabiliste ont été mises en oeuvre notamment par Faugeras et Ayache pour
la reconnaissance d'objets partiellement visibles.
A partir d'un étiquetage initial des primitives, elles permettent de tendre après un certain nombre d'itérations vers un
étiquetage compatible avec un « modèle du mode » à l'aide des positions relatives des primitives de l'image et des
contraintes de position du modèle.
Les primitives consistent en des segments de droite obtenus par approximation polygonale des contours.
Pendant l'apprentissage, à chaque segment du modèle est associé un voisinage constitué de primitives voisines.
Toutes les transformations possibles permettant de passer d'un segment du voisinage à un segment quelconque de la
scène sont élaborées, puis appliquées au segment sur lequel le voisinage est centré.
A chaque transformations sont associées des coefficients de similitude déterminant la qualité de la correspondance. Ils
témoignent de la similitude entre un couple de primitives voisines du modèle et un couple quelconque de primitives de
la scène.
Ils sont également à la base de l'étiquetage initial en permettant de calculer sur des voisinages simples consitutés de
segments adjancents, les probabilités pour chaque segment du modèle d'être apparié à chaque segment de la scène.
Calculés sur des voisinages plus élaborés et grâce à l'étiquetage déjà réalisé, ces coefficients permettent de définir un
nouvel étiquetage pour les voisinages des segments du modèle.
Ce processus est réitéré jusqu'à obtenir deux étiquetages similaires. L'étiquetage final donne alors pour chaque segment
du modèle le segment le plus probable dans la scène, et la position de l'objet recherché peut s'en déduire.
Quoique séduisantes, ces méthodes requièrent néanmoins un espace mémoire et des temps de calcul qui deviennent
importants avec la complexité de la scène.
- La relaxation est une méthode numérique itérative permettant de diminuer progressivement l’ambiguïté d’une
correspondance entre 2 ensembles finis appelés respectivement ensemble des objets et ensemble des étiquettes.
- Relaxation probabiliste
La relaxation discrète présente en particulier l’avantage de la facilité de contrôle de la convergence.

Elle reste limitée en ce qui concerne la prise en compte des informations approximatives qui sont difficiles à traduire en
terme de contraintes booléennes (tout ou rien).
La logique floue peut être utilisée à cet effet. La prise en compte du caractère approximatif de nos connaissances
(traduites dans les contraintes) peut valablement être réalisée à l’aide d’un schéma probabiliste.
6 Annexe. 4
G (modèle) D
1 étiquetage initial des primitives
1 3 1' 3' Ex. : segments étiquetés avec longueur
orientation
1'' centre de gravité ...
2 2'
4 5 4' 5' 2 apprentissage : chaque segment
6'
est associé à un voisinage constitué
de primitives voisines (ex : 1 1' 1'' )
3 différence : entre chaque segment et les
voisins associés
4 recalcul sur voisinages plus élaborés

nouvel étiquetage des voisins
5 itération 2 3 4
jusqu'à 2 étiquetages similaires :
c'est-à-dire tel que la différence 3
soit maximale (discrimination la plus forte)
c'est la relaxation
1.2.5. Les méthodes de prédiction-vérification
Déjà évoquées dans d'autres méthodes, elles sont très présentes en Reconnaissance Des Formes.
Souvignier utilise des primitives constituées d'arcs de cercle et des classiques segments de droite. Les primitives sont
déterminées pendant un suivi de contours et toutes les hypothèses sont émises sur la correspondance possible entre le
modèle et une ou plusieurs primitives détectées, y compris pour la correspondance de primitives de taille différente.
Ces hypothèses, par la suite examinées en commençant par les plus plausibles, donnent chacune une position du modèle
en localisant dans l'image les primitives de celui-ci.
La vérification consiste à rechercher ces dernières à l'aide d'une détection fine des contours sur une partie de l'image
susceptible de les contenir.
Des coefficients sont attachés à la plausibilité et à la validité des hypothèses. Une hypothèse invalidée laisse place à une
hypothèse moins plausible si elle existe, et à l'émission de nouvelles hypothèses sinon. Une hypothèse validée au
contraire permet de réviser la position du modèle, en liaison avec l'ensemble des primitives détectées.
Faugeras et Ayache utilisent également une méthode de prédiction-vérification sur des contours segmentés par
approximation polygonale. Les hypothèses sur la position du modèle dans la scène sont émises d'après la mise en
correspondance d'un segment du modèle avec un segment de la scène.
Ces hypothèses peuvent être réduites, d'une part si l'échelle de l'image par rapport au modèle est connue en n'appariant
que les segments de longueur identique au facteur d'échelle près, et d'autre part en se limitant à des "segments
privilégiés" du modèle comme les segments les plus longs.
Après avoir été émise, une hypothèse est vérifiée par la mise en correspondance successive de chaque primitive au
modèle avec un segment de la scène.
La prédiction détermine la position d'un nouveau segment du modèle dans la scène par une transformation établie à
partir des segments déjà mis en correspondance.
La vérification donne une mesure de la ressemblance du segment prédit avec les segments de l'image de même
orientation.
La primitive associée à la meilleure mesure est mise en correspondance avec le segment du modèle.
Une mesure insuffisante conduit à considérer ce dernier comme non visible.
6 Annexe. 5
A chaque mise en correspondance, la position du modèle est révisée, de telle sorte à rendre minimale la distance
séparant les milieux des segments appariés.
Une mesure de qualité, également réactualisée, est définie en faisant le produit de la longueur des segments identifiés du
modèle avec la mesure de ressemblance entre ces segments et leurs homologues dans l'image.
Ce critère permet d'abandonner une hypothèse en cours si la mesure de qualité descend en dessous de celles obtenues
pour les hypothèses déjà traitées (cas de segments cachés par exemple). Il peut aussi privilégier cette hypothèse dans le
cas d'une mesure de qualité exceptionnelle.
La position du modèle donnée par l'hypothèse retenue est encore réajustée en considérant l'ensemble des primitives
identifiées. Lorsque plusieurs objets sont recherchés, les modèles qui leurs sont rattachés sont appliqués tour à tour sur
les segments de l'image.
De telles méthodes présentent l'avantage de réduire de coût de la reconnaissance par l'examen d'hypothèses classées par
ordre de plausibilité décroissante, les hypothèses retenues étant souvent les premières examinées. En conséquence, elles
nécessitent de disposer de primitives robustes et précises.
1.2.6. Les méthodes utilisant la transformée de Hough
La Transformation de Hough permet de détecter des portions de courbes paramétrées.
Sabbah l'a examinée comme un modèle parallèle de calcul des paramètres géométriques en vision par ordinateur. L'idée
est de décrire la forme d'un objet en termes de paramètres géométriques. Un objet de l'image est alors représenté comme
un point dans l'espace à n dimensions formé par les n paramètres descriptifs (l'espace des paramètres).
Par exemple, les objets en forme de segments de droite dans une image peuvent être complètement décrits par deux
paramètres (ρ,θ), où ρ mesure la distance à l'origine de la droite contenant l'objet et θ son inclinaison . Un point
spécifique dans l'espace des paramètres (ρ,θ) correspond à une ligne dans l'espace image.
Une approche utilisant ce type de représentation consiste à transformer l'espace image en espace des paramètres, et à
rechercher les points appropriés dans cet espace.
Elles comprend quatre étapes :
1) Décomposition uniforme de l'image d'entrée en petite régions (dans l'exemple simple où l'on recherche des objets en
forme de segments de droite, ces régions peuvent être de 3x3 pixels).
2) Examen individuel de ces petites régions pour mettre en évidence les paramètres géométriques recherchés, et
extraction des paramètres (ρ,θ) pour chaque contour d'une petite région.
3) Calcul des votes locaux pour former l'espace des paramètres :

chaque contour peut voter dans un point spécifique (ρ,θ) de l"espace des paramètres. Un point de l'espace des
paramètres accumule les votes de telle sorte à accroître sa densité locale.
4) Balayage de l'accumulateur (ici à deux dimensions) de l'espace des paramètres pour rechercher les points de plus
haute densité.
La reconnaissance d'objets plus complexes que de simples droites peut être faite en les considérant comme constitués de
caractéristiques plus simples, qui à leur tour peuvent être décomposées, et ainsi de suite.
En décrivant les caractéristiques avec un certain nombre de paramètres, on peut construire une hiérarchie des espaces de
paramètres correspondant exactement avec les objets complexes à reconnaître.
La transformation d'une caractéristique dans l'espace devient alors l'image d'entrée pour le prochain espace de
paramètres.
6 Annexe. 6
Par exemple, les cubes peuvent être divisés en faces qui elles-mêmes sont constituées de segments, formés quant à eux
de contours.
Une telle hiérarchie des espaces de paramètres ou de caractéristiques est une hiérarchie conceptuelle.
Une approche ascendante auusi stricte n'est cependant applicable qu'à des images parfaites.
Afin de tenir compte des imperfections telles que le bruit issu de différents transducteurs, pertes d'information et
occlusions, on doit introduire des informations descendantes ou des retours permettant de faire des remises en question.
Pour permettre un bon contrôle des différentes sources d'information, il est introduit des techniques d'éliminations
itératives ou de relaxation.
Sabbah s'intéresse à des objets du monde d'Origami défini par Kanade. Ce sont des objets composés de segments de
droite et délimités par des surfaces planes qui ne s'interpénètrent pas dans l'espace 3D. Sabbah autorise en plus par
rapport à Kanade le cas d'entrée imparfaite et d'occlusions éventuelles.
La représentation de ces objets utilise la détermination de deux vecteurs comme paramètres pour caractériser un
parallélogramme. Un objet d'Origami est alors constitué d'une lsite de vecteurs centrée sur un point particulier de l'objet,
au centre d'un cadre de référence pouvant tourner et être translaté avec l'objet dans l'espace 2D.
Cette représentation peut être étendue pour être également appliquée à des objets plus complexes. Les paramètres sont
de ce fait plus nombreux.
La phase ascendante, utilisant la transformation de Hough consiste à déterminer les vecteurs associés à un objet (d'après
la détection par exemple des coins dans le cas d'un parallèlogramme) et à faire évoluer les autres paramètres de l'objet
dans une plage donnée pour construire l'accumulateur ds votes de la transformation.
La phase descendante (feedback), nécessite dans le cas d'entrée imparfaite, consiste à décomposer, par exemple une face
paramétrée avec les coins qui la constituent.
L'information de retour permettant de faire des remises en cause est issue de techniques itératives, et consiste dans
l'évalution d'un taux de confiance sur la densité des votes :
celui-ci est réactualisé par la prise en compte des nouvelles caractéristiques présentes à l'itération courante et
d'informations de mise en défaut provenant de caractéristiques antagonistes à cette itération.
A chaque itération, le taux de confiance est diminué d'une grandeur dite de décadence, permettant de limiter la saturation
du taux de confiance dûe au processus de relaxation.
En présence de bruit, le système réagit de telle sorte à éliminer le bruit mais seulement après que la partie bruitée ait
obtenu un taux de confiance sufisamment élevé.
Le cas de manque d'informations ou d'occlusions est traité similairement mais l'hypothèse de continuité des formes est
en plus utilisée.
L'apprentissage et la reconnaissance de nouveaux objets peut être envisagée avec des paramètres plus importants et la
prise en compte d'informations de couleur, de texture, de mouvement ...
Grimson et Huttenlocher ont analysé la sensibilité de la transformation de Hough pour la reconnaissance de formes, par
l'étude de la redondance des votes et de la probabilité d'avoir des groupes aléatoires dans l'accumulateur aussi importants
que ceux résultant d'une mise en correspondance correcte.
Ils ont mis en évidence :

- le nombre important de transformations possibles relatives à un modèle et aux caractéristiques de l'image.
- le nombre également important de cases de l'accumulateur issu de telles transformations.
- le nombre important d'appariements tombant par hasard dans une même case de l'accumulateur, obligeant un système
de reconnaissance à examiner de larges parties de l'accumulateur.
Ils concluent sur les services rendus par la transformation de Hough pour des cas particuliers de reconnaissance, mais
sur le fait qu'elle n'est pas appropriée à des environnements complexes.
Fort attrayante par le caractère global de son approche, la transformation de Hough se révèle délicate à mettre en
pratique et à un prix très élevé en temps calcul (taille rapidement importante de l'accumulateur).
6 Annexe. 7
b
a
Parallèlogramme et vecteurs associés. Représentation d'une chaise d'Origami par un ensemble de vecteurs.
Parallèlogramme paramètres associés
(m,n) : coordonnées du centre

b (a;b) : vecteurs
(m,n) a
(dx, dy) : longueur des vecteurs
dx
dy
Polyèdre Paramètres associés
w2 dy
(m,n) w1 wb
w dz dx
3
(mn,) : coordonnées du centre

wb : orientation % horizon
(w1 w2 w3 ) : axe des polyèdres
(dx, dy, dz) : longueur des axes
Paramètres utilisés pour permettre l'identification d'objets plus complexes.
Décomposition d'une face paramétrée avec les coins qui la constituent (Feedback).
6 Annexe. 8
1.3. Conclusion
Chacune des différentes méthodes évoquées s'adapte plus à un problème quà un autre, avec un coût en temps calcul et en
espace mémoire différent.
Dans le cas qui nous occupe où des polyèdres sont à identifier dans les images réelles, traitées par une chaîne
d'opérateurs successifs engendrant un bruit non négligeable, les méthodes nécessitant des primitives très fiables ne sont
pas utilisables.
Le temps calcul requis a voulu être du même ordre que ceux des opérateurs bas-niveau précédemment appliqués, ce qui
élimine une partie importante des méthodes présentées.
Les polyèdres à identifier, quoique simples, sont représentés par un modèle abstrait, d'échelle inconnue, donné sous
forme géométrique, et nous avons donc préféré élaborer une méthode d'identification basée sur des critères
géométriques.
2. Méthode géométrique d'extraction de polyèdres

A
D E B
F C
E
B C i D
D
A
B
α C j F
H G
A E
a) b) c)
Concaténation d'un sommet du polygone décrivant le périmètre d'une région :

a) - le sommet C est concaténé (supprimé), car l'angle α en C est proche de 180 degrés (à 5% près).
b) - le sommet B est seulement virtuellement concaténé car il est point de jonction. Cela veut dire qu'il est supprimé pour l'identification du
polygone comme figure géométrique, mais il reste mémorisé dans le graphe, car il témoigne que les régions i et j sont connexes.
- le sommet F est supprimé, trop proche du sommet et point de jonction A (distance inférieure à 5% de la longueur du polygone AFGHBA.
c) - le critère angulaire est prioritaire sur le critère de longueur : le point de jonction F est virtuellement concaténé, ce qui évite de supprimer le
sommet A, proche de F.
Concaténation des sommets

de la région i
Il possède 3 sommets Il possède 4 sommets

TRIANGLE [QUADRILATERE]
3 côtés 1 angle 2 côtés Angles aux sommets

de même rectangle de même opposés égaux
longueur longueur
1 angle
2 côtés 1 angle rectangle
de même rectangle
longueur 4 côtés
de même longueur
RECTANGLE RECTANGLE ISOCELE ISOCELE CARRE RECTANGLE PARALLELOGRAMME

EQUILATERAL
Forme d'une région pour une région donnée du graphe :

Avec un aperçu de quelques règles permettant la classification de la forme des régions en figures géométriques de base (les tolérances on été fixées
empiriquement à une marge de 20° pour l'égalité des angles (5%) et une marge également de 5% pour l'égalité des longueurs de côtés).
6 Annexe. 9
Ensemble de 3 régions
connexes
2 parallèlogrammes 3 parallèlogrammes 2 parallèlogrammes

et 1 polygone quelconque a quelconques et 1 rectangle
PRISME DE BASE a PARALLELEPIPEDE PARALLELEPIPEDE RECTANGLE
Exemple d'identification des polyèdres à 3 faces visibles.
ENSEMBLE DE 2 REGIONS CONNEXES
2 TRIANGLES 2 PARALLELOGRAMMES 1 TRIANGLE ET

1 PARALLELOGRAMME
1 des angles égalité des angles non égalité la frontière α + β > 180°
les angles
α, β, γ, ou δ
aux sommets de des angles commune (A, B) ou
α, β, γ, δ
est obtu : (δ)
la frontière : aux sommets est telle que : γ + δ > 180°
aux sommets de la
α = δ et γ = β de la frontière α + β ≤ 180°
frontière commune (A, B)
Α et γ + δ ≤ 180°
sont tous aigus
α γ
Β
Α Α
Α
Β
β δ
α
β γ
α Α Β
Α Β Β
β δ
δ
γ
RECONSTRUCTION RECONSTRUCTION RECONSTRUCTION

DE L'OBJET DE L'OBJET DE L'OBJET
PARALLELEPIPEDE
PRISME TRIANGLE
ou
PRISME TRIANGLE
PARALLELEPIPEDE
PRISME TRIANGLE
RECHERCHE
PYRAMIDE PYRAMIDE RECHERCHEE
RECHERCHE
Exemple d'identification des polyèdres convexes à deux faces visibles (marge de 5% tolérée pour les critères relatifs aux angles).
__________
6 Annexe. 10
Traitement d’images Annexe. Tutorial Mathcad
Annexe. Tutorial Mathcad

1. Tour rapide
1.1. Mathcad 2001i
1.2. Les palettes mathématiques (barre d’outils mathématiques) Math Toolbar
1.2.1. La palette arithmétique Calculator toolbar
1.2.2. La palette graphique Graph toolbar
Annexe. 1
1.2.3. La palette matricielle Matrix toolbar
1.2.4. La palette d’évaluation Evaluation toolbar
1.2.5. La palette de calcul Calculus toolbar
1.2.6. La palette de calcul booleen Boolean toolbar
1.2.7. La palette de programmation Programming toolbar
1.2.8. La palette de lettres grecques Greek toolbar
1.2.9. La palette symbolique Symbolic toolbar
Annexe. 2
1.3. Options (Menu Maths → Options)
L’origine des tableau (Array Origin) fixe l’index de base des tableaux et vecteurs. Elle a 0 pour valeur défaut.
Pour manipuler des indices négatifs de vecteurs, l’origine doit être fixée à une valeur négative minimale au-dessous de
laquelle les vecteurs ne sont jamais indexés.
Plutôt que de fixer cette origine par cette boîte de dialogue, on peut aussi le faire par la commande Mathcad :
ORIGIN := -1000
qui autorise alors la manipulation des indices de vecteurs de ORIGIN= -1000 à une valeur maximale dépendant de la
mémoire RAM disponible (un swap disque devient vite rédhibitoire).
1.4. Calcul automatique (Menu Maths → Automatic calculation)
Cette option (débrayable) permet de calculer en temps réel les calculs spécifiés dans la feuille courante.
Les calculs s’effectuent de haut en bas et de gauche à droite dans la feuille de calcul courante.
Pour arrêter un calcul en cours, il suffit d’appuyer sur la touche Echap. La reprise du calcul peut se faire par Calculate
dans le menu Maths après avoir placé le curseur à l’emplacement du calcul à poursuivre.
1.5. Fonctions prédéfinies de la bibliothèque Mathcad (Menu Insert → Function)
Annexe. 3
2. Les bases
2.1. Affectation. Variables globales
Affectation d’une variable a := 5
Affectation d’une fonction f ( t) := sin ( t)
Une affectation est globale à la feuille de calcul. Une variable globale par exemple, est connue dans tout le reste du
document après avoir été définie (donc dans la partie du document inférieure (≡ postérieure) à l’affectation de la
variable).
Toutefois, on peut affecter une variable par exemple, de façon globale dans toute la feuille de calcul (connue même
avant, au-dessus (≡ antérieure) de l’affectation).
 1 −1 
w≡  
L’opérateur correspondant est le suivant : Matrice globale : 0 1 
2.2. Affichage de valeurs
Cet opérateur autorise l’affichage de la valeur d’une variable, d’une matrice, d’une fonction ... issue d’un calcul ou
d’une affectation.
 1 −1 
w= 
a=5 f ( 0) = 0 0 1 
2.3. Variables suites
Annexe. 4
Variables suites entières : k := 0 , 0 + 1 .. 5 ou encore k := 0 .. 5

k=
0
1
2
3
4
5
Variables suites réelles : t := −5, −5 + 0.1.. 5
La syntaxe est la suivante : t := start, start + step .. end step est optionnel (par défaut step = 1)
2.4. Vecteurs et fonctions
0
1
 
x=  
2
3
4
 
xk := k 5
Vecteurs
Fonctions y( k) := k y = function
L’usage des vecteurs est en général préférable à celui des fonctions notamment dans le cas de fonctions récursives, très
coûteuses en espace mémoire.
2.5. Graphique
6 6
5 5
4 4
xk y( k)
2 2
0 0 0 0
0 2 4 6 0 2 4 6
0 k 5 0 k 5
6 1
5 1
xk f ( t) 0
0 0 −1 1
0 2 4 6 5 0 5
0 k 5 −5 t 5
Annexe. 5
2.6. Variables intégrées
. π π = 3.142
. e e = 2.718
307
. ∞ ∞ = 1 × 10
. FRAME
2.7. Fonctions prédéfinies
. Fonction échelon
2
2
u( t )
0
−1
t := −5, −5 + 0.1.. 5 u( t) := Φ ( t)
5 0 5
Echelon à TC −5 t 5
2
2
vk
0
−1
ORIGIN:= −100 k := −5 .. 5 v k := Φ ( k) 5 0 5
Echelon à TD −5 k 5
. Distribution delta
1 .10
307
307
1×10
. 306
u( t) 5 10
u( t) := ∞ if t 0
0 0
t := −5, −5 + 0.5.. 5
5 0 5
Delta à TC 0 otherwise −5 t 5
2
2
vk
0
v k := 1 if k 0
−1
k := −5 .. 5 v k := δ( k , 0) 0 otherwise
5 0 5
Delta à TD ou encore −5 k 5
2.8. Calcul symbolique
Transformée de Laplace d’une fonction (échelon)
1
G( s ) := g( t) laplace , t →
g ( t ) := Φ ( t ) s
Transformée de Laplace inverse
h( t) := G( s ) invlaplace , s → 1 (h(t) est implicitement causale)
Annexe. 6
2.9. Programmation
A l’intérieur d’un programme, les variables sont locales :

l’instruction d’affectation globale := n’est alors pas permise et l’affectation locale se fait par ←.
Le résultat d’un programme (la valeur de retour) par contre, est globale à la feuille de calcul.
. Définition d’une fonction (fenêtre)

2
2
c( t) := 0 if t < −2 c( t)
0
0 if t > 2
−1
t := −10, −10 + 0.1.. 10

10 0 10
1 otherwise − 10 t 10
. Programme d’inversion vidéo d’une image
Rappels
Image digitalisée = tableau 2D IM de n lignes et p colonnes : IM [0: p-1, 0: n-1]
IM[x, y] = niveau de gris du pixel de coordonnées x et y : 0 ≤ x ≤ p-1 0 ≤ y ≤ n-1
0 ≤ IM[x, y] ≤ 255 (0 : Noir 255 : Blanc)
0 x NX-1
0
X
y
IM[x,y]
NY-1
Image NX : nombre de colonnes (p)
NY : nombre de lignes (n)

Y
ORIGIN:= 0
I := READBMP( "bato2.bmp" ) Nombre de colonnes : Nx := cols ( I) Nx = 128
Nombre de lignes : Ny := rows ( I) Ny = 128
Traitement 2D :
T2D( U) := for y ∈ 0.. rows ( U) − 1 K := T2D( I)

for x ∈ 0.. cols ( U) − 1
J ← 255 − U
y,x y,x
I return J K
Traitement 1D (colonne) :
T1Dy( f ) := for y ∈ 0 .. length ( f ) − 1 T1D( U) := for x ∈ 0 .. cols ( U) − 1 L := T1D( I)

g ← 255 − f 〈x〉
y y f←U
g 〈x〉
J ← T1Dy( f )
J L
0 1 2 3 4 0 1 2 3 4
0 185 186 166 165 183 0 70 69 89 90 72
1 184 189 166 166 183 1 71 66 89 89 72
I= K=
2 184 182 157 170 180 2 71 73 98 85 75
3 186 186 152 173 187 3 69 69 103 82 68
4 193 190 149 177 178 4 62 65 106 78 77
Annexe. 7
2.10. Equations récurrentes
Filtre récursif (générateur d’écho) y k = x k + α y k −1 avec xk = δ k et α = 0.7
k := 0.. 20 x := δ( k , 0) α := 0.7 y := x if k 0
k k k
x + αy otherwise
k k− 1
ou encore :
y := α ← 0.7
for k ∈ 0 .. 10
x ← δ( k , 0)
k
y ←x if k 0
k k
y ← x + α⋅y otherwise
k k k− 1
y
1
1
yk 0.5
−4
7.979×10 0
0 10 20
0 k 20
2.11. Animation
Une variable prédéfinie (FRAME) autorise l’animation d’un graphique par exemple, en l’utilisant dans une variable
suite :
100
100
gn 50
0
2 0
n := 0.. FRAME g n := n 0
0
5
n
10
10
3. Aide et Collaboratory
. Aide
Annexe. 8
. Resource center (Quicksheets, Collaboratory (http://collab.mathsoft.com/~Mathcad2001i/) ...)
__________
Annexe. 9
Traitement d’Images Projets
PROJETS
Projets. 0
Projets de Traitement numérique des images

. ~ 3 élèves par groupe de projet
. Projet libre possible (soumis à l’accord du professeur)
. Projet à rendre par mail (ga@eisti.fr) = zip avec programme exécutable + source + doc. électronique (Word, HTML, pdf) + soutenance
. Examen oral de soutenance du projet (possibilité de notes différenciées pour les membres d’un même projet)
. La note d’examen final sera constituée de la note du projet modulée par le travail réalisé en TP
. En cas d’absences ou de mauvais résultats en TP, un examen de TP sera demandé en plus du projet
. Temps de réalisation d’un projet (temps moyen estimé) : 4 séances de 3h.
. Date limite de remise/soutenance du projet : 10ème semaine (dernière séance); puis -1 à la note finale par jour de retard.
A. Extension des Travaux Pratiques
1 Implémentation du filtre détecteur de contours de Deriche (cf. polycopié du cours).
2 Implémentation de l’algorithme de fermeture des contours (cf. polycopié du cours).
3 Implémentation de l’algorithme d’étiquetage des régions (cf. polycopié du cours).
4 « Coloriage » (étiquetage) par remplissage de régions.
5 Construction de la LUT d’affinage des contours (cf. polycopié du cours).
6 Implémentation de la Transformation de Hough (cf. polycopié du cours).
7 Implémentation de la squelettisation d’images bi-niveaux (cf. polycopié du cours).
8 Recalage d’images d’une séquence d’images avec recouvrement, pour une application de vision panoramique
(recouvrement automatique d'images).
B. Exploration
1 Indexation d’images par le contenu (Etude bibliographique).
2 Déformation d’images (à la souris) (faire sourire la bouche d’un visage etc...)
3 Simulation du mouvement de vagues sur une image (sur l’image entière).
4 Mixage d’images : addition, transparence ...
5 Reconnaissance d’empreintes digitales dans une base de données (détection et mise en correspondance –
matching - de minuties).
6 Transformation en ondelettes sur images. Compression. Transformation inverse.
7 Plate-forme logicielle de Traitement d’images (en Visual C).
8 Détection dans un visage, des zones (bouche, yeux, sourcils) pour une application d’expression de l’intonation,
du mouvement des lèvres synchronisé avec la parole et des émotions d’un assistant virtuel parlant (synthèse de parole) à
partir d’un texte.
9 Animation dans un visage, des zones (bouche, yeux, sourcils) pour une application d’expression de l’intonation,
du mouvement des lèvres synchronisé avec la parole et des émotions d’un assistant virtuel parlant (synthèse de parole) à
partir d’un texte.
10 Zoom fractal (pour images fractales) & Compression fractale d’images (pour images raster).
11 Saisie automatique de questionnaires.
12 Morphing d’images.
13 Toolbox Image pour Mathcad (DLL écrite en VisualC pour Mathcad).
14 Toolbox Image écrite en Mathcad.
15 Logiciel d’OCR sur texte dactylographié (algorithme de Jung Pyo Hong ou Transformée de Hough).
15’ Reconnaissance de caractères par réseaux de neurones.
16 Mise en correspondance (reconnaissance) d’une photo d’identité d’un individu scannée, parmi une cinquantaine
de photos d’identité de sujets (autres ou le présent individu) scannées, pour dire OUI l’individu présenté est le sujet n°X
dans la base de données, ou NON, il est nouveau dans la base et on l’enregistre dans la base de données.
17 Reconnaissance faciale : Mise en correspondance (reconnaissance) d’une signature manuscrite d’un individu
scannée, parmi une cinquantaine de signatures de sujets (autres ou le présent individu) scannées, pour dire OUI la
signature présentée est la signature n°X dans la base de données, ou NON, elle est nouvelle dans la base et on
l’enregistre dans la base de données.
18 Logiciel permettant d’établir un portrait robot.
19 Transformée de Fourier, de Walsh, de Hadamard d’une image.
20 Logiciel permettant de concevoir un portrait robot à partir d’une bibliothèque d’éléments du visage.
21 Programme incluant : lissage de Nagao + Filtre de détection de Contours de Deriche NON récursif +
Etiquetage des régions.
22 Composition d’une image à partir d’une mosaïque d’images en BDD (le pixel élémentaire de l’image devient
une image étiquette d’une image en BDD).
23 Tatouage d’images : Insertion de filigranes (watermarking, fingerprint) pour authentification d’images,
détection de modification d’images.
Projets. 1
24 Stéganographie (cryptage d’image, insertion d’un fichier caché dans une image).
25 Stéréovision : calcul 3D (carte des profondeurs, image 3D) à partir de 2 images 2D gauche et droite.
26 Vieillissement facial (facial age progression) semi-automatique (automatisation des opérations sous Photoshop par ex.)
http://morph.cs.st-andrews.ac.uk//Transformer/index.html et http://www.worth1000.com/tutorial.asp?sid=161116&page=1
27 Compression d’images : RLE, FFT, DCT (Jpeg), Ondelettes (Jpeg 2000).
C. Bioinformatique
1 Comptage des spots (grains d'or) greffes sur anticorps par flou + contours
2 Mise en forme et Analyse de Transcriptome et de génome par Transformée en ondelettes
3 Reconnaissance de signatures de génomes bactériens par localisation des bandes du gel
4 Reconnaissance de signatures de génomes bactériens par quantification des bandes du gel (agarose gels)
5 Analyse d’images de puces à ADN (segmentation de spots).
D. Video
1 Editeur/player de vidéo avi (frame by frame, couper/coller, ...) (son en option). Extraction d’une image (frame)
particulière.
2 Programme de codage/décodage JPEG image + implémentation comme DLL Mathcad. Etude bibliographique.
3 Détection automatique de changement de scène dans une séquence vidéo avi.
4 Filtrage d’image Temps Réel (point par point) sous CVI, avec affichage en ligne (juste après traitement du
point courant) (au fur et à mesure du traitement de l’image).
5 Insertion de sous-titres dans une séquence vidéo à partir d’un fichier texte avec localisation du texte
spatialement (dans l’image) et temporellement (frames de début et de fin).
6 Suivi de cible (Kernel tracking, object tracking - Modèle histogramme des n régions autour de la cible -
Algorithme « meanshift »)
E. Articles IEEE
(IP) : Image Processing (cf. répertoire Corriges/ga/ieee)
ANNEXE
__________
Projets. 2
View publication stats

Traitement Numerique Des Images

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Traitement Numerique Des Images

Transféré par

Droits d'auteur :

Formats disponibles

Traitement d'Images 2010 - 2011

TRAITEMENT NUMERIQUE DES IMAGES

EISTI Guy Almouzni

6. Introduction à la Reconnaissance Des Formes (RDF)

[1] H.C. Andrews / B.R. Hunt “ Digital image restoration ” Prentice-Hall

1. Chaîne de vision par ordinateur. Prétraitement - Amélioration d’images

I. CHAÎNE DE VISION PAR ORDINATEUR

1. Chaîne de vision par ordinateur

2. Domaines d'application du traitement d'images

- Robotique - assemblage de pièces, contrôle qualité (ex. identification de code-barre d’une

3. Configuration Matérielle et Logicielle d'un système de traitement d'image

2) Pas de contrainte temps réel (ex. : développement, recherche)

→ Algorithmes implémentés sur l'ordinateur : plus lent mais plus souple.

Architecture matérielle d'un système complet de traitement d'image.

A chaque ligne correspond un signal analogique proportionnel à l'intensité

- Caméra CCD : (Charge Coupled Device) :

- Caméra CCD matricielle :

- Caméra uniligne : (scanner) :

- Processeur analogique : gestionnaire des entrées-sorties vidéo du système.

Fonctions : - sélection de la caméra active, de l'écran d'affichage

numérisation = échantillonnage et quantification (codage)

- Mémoire d'image (frame buffer)

NY : nombre de lignes (n)

Niveau de gris : 0 → noir

- Le Processeur numérique d'images

Il effectue les traitements s'il n'y a pas de contrainte temps réel.

Stockage des fichiers images.

4. Représentation des images

Caractéristiques principales des images raster

Numérisation des signaux analogiques vidéo

L’interface graphique SVGA

Perception des couleurs

Représentation ITS de Munsell

Système HLS (Hue, Saturation, Ligthness) et HSV (Hue, Saturation, Value)

Formats des fichiers images

Organisation d'un format graphique bitmap : entête + données

Un fichier graphique est en général constitué deux parties :

Etapes de l’analyse d’images

Exemples d’opérations sur images

Différence de deux images

Opérations entre images

Différence de deux images

Les domaines d’application du Traitement d’Images

Logiciels de Traitement d’Images

Outil de développement pour les Travaux Pratiques

Répertoire de stockage des images : décompactage de \CORRIGES\GA\TI\ImBmp.exe

Exemples d'images : Bato.bmp (source: CNRS) et Coco.bmp :

Bato.bmp (NX*NY*DYN = 256*256*256 ) Coco.bmp (147*195*256)

II. PRETRAITEMENT - AMELIORATION D'IMAGES

1. Amélioration et restauration d'images

- Restauration (image restoration)

Restitution de l'image aussi proche que possible qu'avant dégradation.

- à priori : modèle H(u,v) construit à partir d'images tests (identification):

im[x,y] Restauration wm[x,y] TEMPS

IM[u,v] 1/H(u,v) WM[u,v] FREQUENCE

Image dégradée Image restaurée

- Amélioration d'images (image enhancement) :

2. Histogramme d'une image (traitement statistique de l’image)

Inconvénient du traitement statistique : Perte de l’information de localisation.

Avantage du traitement statistique : Traitement global.

Objets Fond 255

Valeur à choisir pour le seuil de binarisation

Algorithme du calcul de l'Histogramme d'une image de taille NX*NY et de dynamique D :

Pour y = 0 à NY-1 Faire

Bato.bmp (NXNYDYN = 256256256 ) Coco.bmp (147195256)