Chapitre 1

Segmentation des images

1.1 Le seuillage
Le seuillage est une technique fondamentale en traitement d’images utilisée pour seg-
menter des images en distinguant les objets d’intérêt de l’arrière-plan. Il s’agit de trans-
former une image en niveaux de gris en une image binaire ou semi-binaire en appliquant
un ou plusieurs seuils.
Dans ce cours, nous aborderons les méthodes suivantes :
1. Seuillage Classique
2. Seuillage Tronqué
3. Seuillage à Zéro
4. Seuillage Optimal Itératif

1.2 Seuillage Classique

Le seuillage classique, également appelé seuillage binaire, consiste à convertir une
image en niveaux de gris en une image binaire en appliquant un seuil fixe T . Les pixels
ayant une intensité inférieure à T sont mis à zéro (noir), et ceux ayant une intensité
supérieure ou égale à T sont mis à la valeur maximale (blanc).

Soit f (x, y) l’intensité du pixel à la position (x, y) dans l’image originale, et g(x, y)
l’intensité du pixel dans l’image seuillée :

0, si f (x, y) < T
g(x, y) =
255, si f (x, y) ≥ T

1.2.1 Exemple de Code

1
 1.2. SEUILLAGE CLASSIQUE
CHAPITRE 1. SEGMENTATION DES IMAGES

import cv2
import numpy as np
import matplotlib . pyplot as plt

# Charger l ’ image en niveaux de gris

image = cv2 . imread ( ’ image . jpg ’ , cv2 . IMREAD_GRAYSCALE )

# Definir le seuil
T = 128

# Appliquer le seuillage classique

_ , binary_image = cv2 . threshold ( image , T , 255 , cv2 . THRESH_BINARY )

# Afficher l ’ image originale et l ’ image seuillee

plt . figure ( figsize =(10 ,5) )
plt . subplot (1 , 2 , 1)
plt . imshow ( image , cmap = ’ gray ’)
plt . title ( ’ Image Originale ’)
plt . axis ( ’ off ’)

plt . subplot (1 , 2 , 2)
plt . imshow ( binary_image , cmap = ’ gray ’)
plt . title ( ’ Image Seuillee ( Classique ) ’)
plt . axis ( ’ off ’)

plt . show ()

Figure 1.1 – Seuillage Classique

2
CHAPITRE 1. SEGMENTATION DES IMAGES
1.3. SEUILLAGE TRONQUÉ

1.3 Seuillage Tronqué

Le seuillage tronqué remplace les pixels dont l’intensité dépasse le seuil T par la
valeur du seuil, tout en conservant les autres pixels inchangés. Cela permet de limiter les
valeurs maximales dans l’image.

1.3.1 Expression Mathématique


f (x, y), si f (x, y) ≤ T
g(x, y) =
T, si f (x, y) > T

1.3.2 Exemple de Code Python

import cv2
import numpy as np
import matplotlib . pyplot as plt

# Charger l ’ image en niveaux de gris

image = cv2 . imread ( ’ solid2 . png ’ , cv2 . IMREAD_GRAYSCALE )

# Definir le seuil
T = 128
# Appliquer le seuillage tronque
_ , truncated_image = cv2 . threshold ( image , T , 255 , cv2 .
THRESH_TRUNC )

# Afficher l ’ image originale

plt . figure ( figsize =(10 ,5) )
plt . subplot (1 , 2 , 1)
plt . imshow ( image , cmap = ’ gray ’)
plt . title ( ’ Image Originale ’)
plt . axis ( ’ off ’)

# Afficher l ’ image seuillee

plt . subplot (1 , 2 , 2)
plt . imshow ( truncated_image , cmap = ’ gray ’)
plt . title ( ’ Image Seuillage Tronque ’)
plt . axis ( ’ off ’)
plt . show ()

3
 1.4. SEUILLAGE À ZÉRO
CHAPITRE 1. SEGMENTATION DES IMAGES

Figure 1.2 – Image Seuillage Tronque

1.4 Seuillage à Zéro

Le seuillage à zéro met à zéro les pixels dont l’intensité est inférieure ou égale au
seuil T , tout en conservant les pixels supérieurs au seuil inchangés. Cette méthode met
en évidence les régions claires de l’image.

1.4.1 Expression Mathématique


0, si f (x, y) ≤ T
g(x, y) =
f (x, y), si f (x, y) > T

1.4.2 Exemple de Code Python

# Appliquer le seuillage a zero

_ , tozero_image = cv2 . threshold ( image , T , 255 , cv2 . THRESH_TOZERO )

# Afficher l ’ image seuillee

plt . imshow ( tozero_image , cmap = ’ gray ’)
plt . title ( ’ Image Seuillage a Zero ’)
plt . axis ( ’ off ’)
plt . show ()

4
CHAPITRE 1. SEGMENTATION
[Link]
SEUILLAGE
IMAGES OPTIMAL ITÉRATIF

Figure 1.3 – Image Seuillage à zéro

1.5 Seuillage Optimal Itératif

Le seuillage optimal itératif est une méthode automatique pour trouver le seuil
optimal en utilisant une approche itérative. L’algorithme ajuste le seuil jusqu’à ce que la
différence entre le nouveau seuil et l’ancien soit négligeable.

1.5.1 Étapes de l’Algorithme

1. Initialisation : Choisir un seuil initial T0 , généralement la moyenne des intensités
de l’image.
2. Segmentation : Diviser l’image en deux groupes G1 et G2 en fonction de Tk .
3. Calcul des Moyennes : Calculer les moyennes µ1 et µ2 des pixels dans G1 et G2 .
µ1 + µ2
4. Mise à Jour du Seuil : Calculer le nouveau seuil Tk+1 = .
2
5. Vérification de Convergence : Si |Tk+1 − Tk | < ε, arrêter l’itération.

1.5.2 Expression Mathématique

µ1 + µ2
Tk+1 =
2
1 X 1 X
avec µ1 = f (x, y), µ2 = f (x, y)
|G1 | f (x,y)∈G1 |G2 | f (x,y)∈G2

5
 1.5. SEUILLAGE OPTIMAL
CHAPITRE
ITÉRATIF
1. SEGMENTATION DES IMAGES

1.5.3 Exemple de Code Python

def itera t iv e _ th r e sh o l d ( image , epsilon =0.5 , max_iterations =100) :

# Initialiser le seuil avec la moyenne des intensites
T_old = np . mean ( image )
iteration = 0

while iteration < max_iterations :

# Diviser l ’ image en deux groupes
G1 = image [ image > T_old ]
G2 = image [ image <= T_old ]

# eviter la division par zero

if len ( G1 ) == 0 or len ( G2 ) == 0:
break

# Calculer les moyennes des groupes

mu1 = np . mean ( G1 )
mu2 = np . mean ( G2 )

# Calculer le nouveau seuil

T_new = ( mu1 + mu2 ) / 2

# Verifier la convergence
if abs ( T_new - T_old ) < epsilon :
break

T_old = T_new
iteration += 1

# Appliquer le seuillage avec le seuil optimal

_ , optimal_image = cv2 . threshold ( image , T_new , 255 , cv2 .
THRESH_BINARY )
return optimal_image , T_new

# Utiliser la fonction sur l ’ image

optimal_image , op timal_ thresh old = i te r a t iv e _ th r e sh o l d ( image )

print ( f " Seuil optimal trouve : { opti mal_th reshol d } " )

# Afficher l ’ image seuillee

plt . imshow ( optimal_image , cmap = ’ gray ’)
plt . title ( ’ Image Seuillage Optimal Iteratif ’)
plt . axis ( ’ off ’)
plt . show ()

6
CHAPITRE 1. SEGMENTATION DES IMAGES
1.6. LA SEGMENTATION

Figure 1.4 – Image Seuillage itératif

Le seuillage est une technique essentielle pour la segmentation d’images. Le choix de

la méthode dépend de l’application spécifique :
— Seuillage Classique : Simple et rapide, nécessite un seuil fixé manuellement.
— Seuillage Tronqué : Utile pour limiter les valeurs maximales sans perdre les
détails des zones sombres.
— Seuillage à Zéro : Met en évidence les zones claires de l’image.
— Seuillage Optimal Itératif : Fournit un seuil optimal calculé automatiquement.

1.6 La segmentation
1.6.1 Définition
La segmentation vise à découper une image en régions connexes présentant une ho-
mogénéité selon un certain critère.

La segmentation est une étape essentielle dans le traitement des images et trouve des
applications dans de nombreux domaines, où la nécessité de diviser une image en régions
significatives est primordiale. Voici quelques-uns des principaux domaines d’application
de la segmentation :

1.6.2 Imagerie Médicale

Dans le domaine de l’imagerie médicale, la segmentation est utilisée pour identifier
et délimiter des structures anatomiques telles que les organes, les tumeurs, et les tissus
spécifiques. Par exemple, la segmentation des IRM est couramment utilisée pour isoler
des zones du cerveau, détecter des lésions, ou mesurer la taille des tumeurs.

7
 1.6. LA SEGMENTATION
CHAPITRE 1. SEGMENTATION DES IMAGES

Figure 1.5 – Segmentation d’image dans le domaine médical

1.6.3 Vision par Ordinateur et Reconnaissance d’Objets

la segmentation est une étape clé pour la reconnaissance d’objets. Elle permet de di-
viser une image en régions qui représentent des objets ou des parties d’objets, facilitant
ainsi des tâches comme la détection d’objets, la reconnaissance de formes et la classifica-
tion d’images. Par exemple, dans la conduite autonome, la segmentation est utilisée pour
distinguer les piétons, les véhicules, et les panneaux de signalisation.

Figure 1.6 – Segmentation d’image dans le domaine Reconnaissance d’Objets

1.6.4 Imagerie Satellite

En imagerie satellite, la segmentation est utilisée pour l’analyse des images de la
surface terrestre. Elle permet d’identifier différents types de couvertures terrestres, comme
les forêts, les plans d’eau, les zones urbaines, et les terres agricoles. Cette application est

8
CHAPITRE 1. SEGMENTATION DES IMAGES
1.6. LA SEGMENTATION

essentielle pour le suivi de l’environnement, l’agriculture de précision, et la gestion des

catastrophes naturelles.

Figure 1.7 – Segmentation d’image dans le domaine d’imagerie Satellite

1.6.5 Réalité Augmentée

Dans le domaine de la réalité augmentée et de la virtualisation, la segmentation
est utilisée pour isoler des objets ou des personnes du fond afin de les intégrer dans un
environnement virtuel. Cela est couramment utilisé pour créer des expériences immersives
dans des jeux vidéo, des applications éducatives, ou des démonstrations de produits.

Figure 1.8 – Segmentation d’image dans le domaine de la réalité Augmentée

La segmentation d’images est une étape cruciale en traitement d’images, visant à

9
 1.7. SEGMENTATION CHAPITRE
PAR FUSION
1. SEGMENTATION DES IMAGES

partitionner une image en régions significatives pour faciliter son analyse ou son inter-
prétation. Dans ce cours, nous aborderons :
1. Segmentation par fusion
2. Segmentation par Division
3. Segmentation par Division et Fusion
4. Détection de Contour avec le Code de Freeman

Figure 1.9 – Segmentation d’image

1.7 Segmentation par fusion

1.8 Introduction
La segmentation par fusion est une technique de traitement d’images qui consiste à
partitionner une image en régions homogènes en fusionnant des pixels adjacents sur la base
d’un critère de similarité. Cette méthode est couramment utilisée dans des domaines tels
que la vision par ordinateur, la reconnaissance de formes et l’analyse médicale. L’objectif
est de simplifier la représentation d’une image et de faciliter son analyse.

1.8.1 Principe de Base

La segmentation par fusion peut être considérée comme un processus de regroupement
de pixels similaires pour former des régions cohérentes. Le critère de similarité est basé
sur une mesure de dissimilarité, par exemple la différence d’intensité.

10
CHAPITRE 1. 1.9.
SEGMENTATION
ALGORITHMEDES
DE SEGMENTATION
IMAGES PAR FUSION

1.8.2 Critère de Fusion

Soit I une image en niveaux de gris définie sur un domaine discret D ⊂ Z2 , où chaque
pixel p ∈ D a une intensité I(p) ∈ [0, 255].
Deux pixels p et q sont considérés comme similaires (et donc fusionnables) si la diffé-
rence absolue de leurs intensités est inférieure ou égale à un seuil T :

|I(p) − I(q)| ≤ T (1.1)

1.8.3 Voisinage
Pour chaque pixel p, nous considérons un ensemble de pixels voisins N (p). Dans le
cas le plus simple, nous pouvons utiliser la 4-connectivité (haut, bas, gauche, droite) ou
la 8-connectivité (ajoutant les diagonales).

1.8.4 Fusion des Régions

Le processus commence par considérer chaque pixel comme une région distincte. En-
suite, nous parcourons l’image et fusionnons les pixels adjacents qui satisfont le critère
de similarité pour former des régions plus grandes.

1.9 Algorithme de Segmentation par Fusion

L’algorithme de segmentation par fusion suit les étapes suivantes :

1.10 Exemple Simple

Considérons une image en niveaux de gris de petite taille :
 
100 101 102
 99 100 101
Image 3x3 :  

98 99 100
Supposons que le seuil de similarité T = 2.
— Étape 1 : Initialisation. Chaque pixel est une région distincte.
— Étape 2 : Parcours de l’image.
— Commencez par le pixel en position (0,0) avec une intensité de 100.
— Examinez ses voisins :
— (0,1) : Intensité 101, différence |100 − 101| = 1 ≤ 2. Fusionner.
— (1,0) : Intensité 99, différence |100 − 99| = 1 ≤ 2. Fusionner.
— Résultat : Tous les pixels sont fusionnés en une seule région car la différence
d’intensité entre les pixels adjacents est toujours inférieure ou égale à 2.

11
 1.10. EXEMPLE SIMPLE
CHAPITRE 1. SEGMENTATION DES IMAGES

Algorithm 1 Segmentation par Fusion Simple

1: Initialisation :
2: Chaque pixel de l’image est considéré comme une région distincte et reçoit un label
unique.
3: for chaque pixel p de l’image do
4: if le pixel p n’a pas encore été assigné à une région then
5: Créer une nouvelle région avec un label unique.
6: Ajouter le pixel p à cette région.
7: Initialiser une file contenant le pixel p.
8: while la file n’est pas vide do
9: Retirer un pixel q de la file.
10: for chaque voisin n du pixel q do
11: if le pixel n n’a pas encore été assigné à une région et satisfait le critère de
similarité then
12: Assigner le même label au pixel n.
13: Ajouter le pixel n à la file.
14: end if
15: end for
16: end while
17: end if
18: end for

Figure 1.10 – Fusion avec un seuil de 35

12
CHAPITRE 1. SEGMENTATION
[Link]
IMPLÉMENTATION
IMAGES EN PYTHON

Figure 1.11 – Fusion avec un seuil de 35

1.11 Implémentation en Python

Le code Python ci-dessous implémente la segmentation par fusion sur une image en
niveaux de gris. Chaque pixel est considéré comme une région distincte et les régions
adjacentes sont fusionnées si elles satisfont le critère de similarité.

Listing 1.1 – Implémentation en Python de la Segmentation par Fusion

import cv2
import numpy as np
import matplotlib . pyplot as plt

def s i mp l e _r e g io n _ me r g e ( image , threshold ) :

"""
Segmentation par fusion simple pour une image en niveaux de gris .

Parametres :
- image : Image en niveaux de gris ( numpy array 2 D ) .
- threshold : Seuil de difference d intensite pour fusionner les
regions .

Retourne :
- labels : Image des labels des regions segmentees .
"""
h , w = image . shape
labels = -1 * np . ones (( h , w ) , dtype = int )
label = 0

def get_neighbors (y , x ) :
neighbors = []

13
 1.11. IMPLÉMENTATION
CHAPITRE
EN PYTHON
1. SEGMENTATION DES IMAGES

if x > 0:
neighbors . append (( y , x - 1) )
if y > 0:
neighbors . append (( y - 1 , x))
if x < w - 1:
neighbors . append (( y , x + 1) )
if y < h - 1:
neighbors . append (( y + 1 , x))
return neighbors

for y in range ( h ) :
for x in range ( w ) :
if labels [y , x ] == -1:
# Nouvelle region
labels [y , x ] = label
region_intensity = image [y , x ]
# File pour le parcours en largeur
queue = [( y , x ) ]
while queue :
cy , cx = queue . pop (0)
for ny , nx in get_neighbors ( cy , cx ) :
if labels [ ny , nx ] == -1:
intensity_diff = abs ( int ( image [ ny , nx ]) -
int ( region_intensity ) )
if intensity_diff <= threshold :
labels [ ny , nx ] = label
queue . append (( ny , nx ) )
label += 1
return labels

if __name__ == " __main__ " :

# Charger une image en niveaux de gris
image = cv2 . imread ( ’ image_exemple . jpg ’ , cv2 . IMREAD_GRAYSCALE )
# Verifier si l ’ image est chargee
if image is None :
print ( " Erreur : L ’ image n ’a pas pu etre chargee . " )
exit ()

# Parametre de seuil
threshold = 10 # Ajustez ce parametre selon vos besoins

# Appliquer la segmentation par fusion simple

labels = s im p l e_ r e gi o n _m e r ge ( image , threshold )

# Afficher les regions segmentees avec des couleurs differentes

plt . figure ( figsize =(10 , 5) )

plt . subplot (1 , 2 , 1)
plt . imshow ( image , cmap = ’ gray ’)
plt . axis ( ’ off ’)
plt . title ( ’ Image Originale ’)

14
CHAPITRE 1. SEGMENTATION DES IMAGES 1.12. AVANTAGES

plt . subplot (1 , 2 , 2)
plt . imshow ( labels , cmap = ’ nipy_spectral ’)
plt . axis ( ’ off ’)
plt . title ( ’ Segmentation par Fusion ’)

plt . show ()

1.12 Avantages
— Simplicité : Facile à comprendre et à implémenter.
— Contrôle : Le seuil de similarité permet de contrôler la granularité de la segmen-
tation.
— Flexibilité : Peut être adapté pour utiliser différents critères de similarité.

1.13 Limitations
— Performance : Le temps de calcul peut être élevé pour les grandes images.
— Sensibilité au Seuil : Le choix du seuil T est crucial et peut nécessiter des
ajustements manuels.
— Images Couleur : L’algorithme tel quel ne fonctionne que pour les images en
niveaux de gris. Pour les images couleur, il faudrait adapter le critère de similarité.

1.14 Segmentation par Division

1.15 Introduction
La segmentation par division est une méthode qui divise une image en sous-régions
homogènes à l’aide de la structure de Quadtree. Cette segmentation est effectuée de
manière récursive en divisant chaque région en quatre sous-régions jusqu’à ce que le
critère d’homogénéité soit satisfait.
Le critère d’homogénéité peut être la différence entre la valeur de pixel maximale et la
valeur de pixel minimale dans une région, qui doit être inférieure ou égale à un seuil
spécifié, il peut être exprimer sous forme de différence de couleur comme il peut être une
valeur en relation avec la texture.

1.16 Quadtree
Le Quadtree est une structure de données qui permet de diviser récursivement une
région carrée en quatre sous-régions. Chaque nœud dans l’arbre représente une région de
l’image, et les feuilles représentent des régions homogènes.

15
 1.17. CRITÈRE D’HOMOGÉNÉITÉ
CHAPITRE 1. SEGMENTATION DES IMAGES

Figure 1.12 – Division par quadtree

1.17 Critère d’Homogénéité

Soit une image I de taille M × N , où chaque pixel est représenté par une intensité
I(x, y) pour chaque position (x, y) dans l’image.
Le critère d’homogénéité est basé sur la différence maximale des valeurs d’intensité
dans une région. Une région R est considérée homogène si la différence entre l’intensité
maximale et minimale dans cette région est inférieure ou égale à un seuil T :

max I(x, y) − min I(x, y) ≤ T (1.2)

(x,y)∈R (x,y)∈R

Algorithm 2 Algorithme de Segmentation par Division utilisant le Quadtree

1: Initialisation : Commencer avec l’image entière comme une seule région.
2: while il existe des régions non homogènes do
3: for chaque région R do
4: Vérification d’Homogénéité : Vérifier si la région R satisfait le critère d’ho-
mogénéité.
5: if la région R n’est pas homogène then
6: Division : Diviser la région R en quatre sous-régions égales.
7: end if
8: end for
9: end while

1.18 Exemple Simple

Considérons une image en niveaux de gris de 4 × 4 pixels :

50 52 53 55
 
 51 53 54 56 
Image 4x4 : 
 
150 152 153 155


151 153 154 156

16
CHAPITRE 1. SEGMENTATION
[Link]
IMPLÉMENTATION
IMAGES EN PYTHON

Supposons que le critère d’homogénéité est une différence d’intensité maximale de

T = 5.
— Étape 1 : Considérer l’image entière comme une région.
— Étape 2 : La différence maximale entre les valeurs de pixels est 106 (156 − 50),
ce qui dépasse le seuil. Divisez l’image en quatre sous-régions de 2 × 2 pixels.
— Étape 3 : Vérifiez chaque sous-région :
— Les deux sous-régions supérieures ont une différence d’intensité maximale de
5, et les deux sous-régions inférieures ont également une différence d’intensité
de 5. Toutes les sous-régions satisfont donc le critère.
— Résultat : L’image est divisée en quatre régions homogènes.

Figure 1.13 – Fusion avec un seuil de 35

1.19 Implémentation en Python

Le code Python suivant implémente la segmentation par division d’une image avec
le critère de différence maximale des valeurs de pixels et utilise une structure de
Quadtree.
Listing 1.2 – Implementation en Python de la Segmentation par Division avec Quadtree
import cv2
import numpy as np
import matplotlib . pyplot as plt

class Quadtree :
def __init__ ( self , x , y , width , height , level =0) :

17
 1.19. IMPLÉMENTATION
CHAPITRE
EN PYTHON
1. SEGMENTATION DES IMAGES

self . x = x
self . y = y
self . width = width
self . height = height
self . level = level
self . children = []

def is_leaf ( self ) :

return len ( self . children ) == 0

def split ( self ) :

half_width = self . width // 2
half_height = self . height // 2
self . children = [
Quadtree ( self .x , self .y , half_width , half_height , self .
level + 1) ,
Quadtree ( self . x + half_width , self .y , half_width ,
half_height , self . level + 1) ,
Quadtree ( self .x , self . y + half_height , half_width ,
half_height , self . level + 1) ,
Quadtree ( self . x + half_width , self . y + half_height ,
half_width , half_height , self . level + 1)
]

def split_image ( image , threshold ) :

height , width = image . shape
root = Quadtree (0 , 0 , width , height )
regions = []

def split_recursive ( node ) :

x , y , width , height = node .x , node .y , node . width , node . height
sub_region = image [ y : y + height , x : x + width ]

max_intensity = np . max ( sub_region )

min_intensity = np . min ( sub_region )
intensity_diff = max_intensity - min_intensity

if intensity_diff <= threshold or width <= 1 or height <= 1:

regions . append ( node )
else :
node . split ()
for child in node . children :
split_recursive ( child )

split_recursive ( root )

return regions

# Exemple d ’ utilisation
if __name__ == " __main__ " :
image = cv2 . imread ( ’ image_exemple . jpg ’ , cv2 . IMREAD_GRAYSCALE )
if image is None :

18
CHAPITRE 1. SEGMENTATION DES IMAGES 1.20. AVANTAGES

print ( " Erreur : L ’ image n ’a pas pu etre chargee . " )

exit ()

threshold = 10 # Ajustez ce parametre selon vos besoins

regions = split_image ( image , threshold )

output_image = image . copy ()

for node in regions :
x , y , width , height = node .x , node .y , node . width , node . height
cv2 . rectangle ( output_image , (x , y ) , ( x + width , y + height ) ,
(255 , 0 , 0) , 1)

plt . figure ( figsize =(10 , 5) )

plt . subplot (1 , 2 , 1)
plt . imshow ( image , cmap = ’ gray ’)
plt . axis ( ’ off ’)
plt . title ( ’ Image Originale ’)

plt . subplot (1 , 2 , 2)
plt . imshow ( output_image , cmap = ’ gray ’)
plt . axis ( ’ off ’)
plt . title ( ’ Segmentation par Division avec Quadtree ’)

plt . show ()

1.20 Avantages
— Diviser et Régner : L’approche basée sur le Quadtree permet de diviser l’image
de manière adaptative jusqu’à ce que toutes les régions soient homogènes.
— Réduction de Complexité : La structure en Quadtree permet de réduire la
complexité de traitement en se concentrant uniquement sur les régions non homo-
gènes.

1.21 Limitations
— Complexité Computationnelle : Le processus peut être coûteux en termes de
calcul pour des images de grande taille, en particulier si le seuil est trop restrictif.
— Dépendance au Seuil : Le choix du seuil est critique et peut nécessiter des
ajustements manuels.

19
 1.22. SEGMENTATIONCHAPITRE
PAR DIVISION
1. SEGMENTATION
ET FUSION DES IMAGES

1.22 Segmentation par Division et Fusion

1.22.1 Principe
La segmentation par division et fusion combine les approches de division et de
fusion pour améliorer la segmentation. Après la division initiale, les régions adjacentes
similaires sont fusionnées pour obtenir des régions plus grandes et homogènes.

1.22.2 Étapes de l’Algorithme

1. Division : Diviser l’image en régions jusqu’à ce que le critère d’homogénéité soit
satisfait.
2. Fusion : Fusionner les régions adjacentes Ri et Rj si le critère de similarité est
satisfait :

Si |µRi − µRj | < Tfusion , alors fusionner Ri et Rj

où µRi est la moyenne des intensités de Ri et Tfusion est un seuil de fusion.

1.22.3 Exemple de Code Python

def merge ( regions , image , threshold ) :
merged = True
while merged :
merged = False
new_regions = []
used = set ()
for i , ( x1 , y1 , w1 , h1 ) in enumerate ( regions ) :
if i in used :
continue
region1 = image [ y1 : y1 + h1 , x1 : x1 + w1 ]
mean1 = np . mean ( region1 )
merged_with_any = False
for j , ( x2 , y2 , w2 , h2 ) in enumerate ( regions ) :
if j <= i or j in used :
continue
if abs ( x1 - x2 ) <= max ( w1 , w2 ) and abs ( y1 - y2 )
<= max ( h1 , h2 ) :
region2 = image [ y2 : y2 + h2 , x2 : x2 + w2 ]
mean2 = np . mean ( region2 )
if abs ( mean1 - mean2 ) < threshold :
x_min = min ( x1 , x2 )
y_min = min ( y1 , y2 )
x_max = max ( x1 + w1 , x2 + w2 )
y_max = max ( y1 + h1 , y2 + h2 )

20
 1.23. DÉTECTION DE CONTOUR PAR LA CHAINE DE CODE DE
CHAPITRE 1. SEGMENTATION DES IMAGES FREEMAN

new_regions . append (( x_min , y_min , x_max -

x_min , y_max - y_min ) )
used . update ([ i , j ])
merged = True
merged_with_any = True
break
if not merged_with_any and i not in used :
new_regions . append (( x1 , y1 , w1 , h1 ) )
regions = new_regions
return regions

# Apres la division
regions = split ( image , 0 , 0 , image . shape [1] , image . shape [0] ,
threshold =10)

# Appliquer la fusion
regions = merge ( regions , image , threshold =5)

# Visualiser les regions fusionnees

output = np . zeros_like ( image )
for x , y , w , h in regions :
cv2 . rectangle ( output , (x , y ) , ( x + w , y + h ) , 255 , 1)

plt . imshow ( output , cmap = ’ gray ’)

plt . title ( ’ Segmentation par Division et Fusion ’)
plt . axis ( ’ off ’)
plt . show ()

1.23 Détection de Contour par la chaine de Code de

Freeman

1.24 Introduction
La détection de contours est une étape fondamentale en traitement d’images pour
extraire les formes et structures des objets présents dans une image. Elle permet de ré-
duire les données inutiles tout en conservant les informations essentielles sur les limites
des objets.

La chaîne de code de Freeman est une méthode compacte pour représenter les
contours à l’aide d’une séquence de directions dans un espace discret. Elle est utile pour
la reconnaissance de formes, la description de contours et la comparaison de formes.

21
 1.24. INTRODUCTIONCHAPITRE 1. SEGMENTATION DES IMAGES

Concept de la Chaîne de Code de Freeman

Représentation des Directions
La méthode utilise un voisinage 8-connecté pour représenter les directions autour d’un
pixel central. Les directions possibles sont numérotées de 0 à 7 comme suit :

3 2 1
4 P 0
5 6 7
— 0 : Droite
— 1 : Diagonale haut-droite
— 2 : Haut
— 3 : Diagonale haut-gauche
— 4 : Gauche
— 5 : Diagonale bas-gauche
— 6 : Bas
— 7 : Diagonale bas-droite
Chaque pixel du contour est relié à son voisin immédiat par l’une de ces directions.

Étapes du Processus
1. Prétraitement de l’image :
— L’image doit être binarisée (noir et blanc).
— Les contours des objets sont représentés par des pixels noirs (0).
2. Détection du pixel de départ : Trouver un pixel appartenant au contour (par
exemple, en scannant l’image ligne par ligne).
3. Parcours du contour : À partir du pixel de départ, suivre le contour en exami-
nant les pixels voisins selon l’ordre des directions.
4. Boucle fermée : Le processus s’arrête lorsque le contour revient au pixel de
départ.

Algorithme de la Chaîne de Code de Freeman

Entrées
— Une image binaire où les contours sont noirs et l’arrière-plan est blanc.

Sorties
— Une chaîne de Freeman (séquence des directions).

22
CHAPITRE 1. SEGMENTATION DES IMAGES1.24. INTRODUCTION

Pseudo-Code
1. Charger l’image et la binariser.
2. Trouver un pixel appartenant au contour.
3. Initialiser une liste pour enregistrer les directions.
4. Parcourir les pixels voisins dans l’ordre des directions jusqu’à revenir au pixel de
départ.
5. Sortir la chaîne de Freeman.

Figure 1.14 – Détection de Contour par la chaine de Code de Freeman

Exemple Visuel
Image binaire d’entrée :

1 1 1 1 1 1 1
1 0 0 0 1 1 1
1 0 1 0 1 1 1
1 0 0 0 1 1 1
1 1 1 1 1 1 1

Les pixels noirs (0) forment le contour. La chaîne de Freeman pour ce contour serait :

[]

Exemple en Python
Voici une implémentation en Python :
Listing 1.3 – Implémentation Python
import cv2

23
 1.24. INTRODUCTIONCHAPITRE 1. SEGMENTATION DES IMAGES

import numpy as np
import matplotlib . pyplot as plt

def freema n_ ch ai n_c od e ( image ) :

"""
Compute Freeman chain code for a binary image .
"""
rows , cols = image . shape
start = None

# Find the starting pixel on the contour

for i in range ( rows ) :
for j in range ( cols ) :
if image [i , j ] == 0: # Contour pixel ( black )
start = (i , j )
break
if start :
break

if not start :
return []

# Define 8 - connected neighborhood directions

directions = [(0 , 1) , ( -1 , 1) , ( -1 , 0) , ( -1 , -1) , (0 , -1) ,
(1 , -1) , (1 , 0) , (1 , 1) ]
direction_code = list ( range (8) )

chain_code = []
current = start
visited = set ()
visited . add ( current )

while True :
for d , ( di , dj ) in enumerate ( directions ) :
ni , nj = current [0] + di , current [1] + dj
if (0 <= ni < rows ) and (0 <= nj < cols ) and ( image [
ni , nj ] == 0) and (( ni , nj ) not in visited ) :
chain_code . append ( direction_code [ d ])
visited . add (( ni , nj ) )
current = ( ni , nj )
break
else :
break

if current == start : # Close the loop

break

24
CHAPITRE 1. SEGMENTATION DES IMAGES1.24. INTRODUCTION

return chain_code

# Load an RGB image

image_path = ’L :\ IA course \ TP2 / bag14 . png ’ # Replace with your
image path
rgb_image = cv2 . imread ( image_path )

# Convert to grayscale
gray_image = cv2 . cvtColor ( rgb_image , cv2 . COLOR_BGR2GRAY )

# Convert to binary image using thresholding

_ , binary_image = cv2 . threshold ( gray_image , 128 , 255 , cv2 .
THRESH_BI NARY_I NV )

# Compute Freeman chain code

chain_code = f re em an _ch ai n_ co de ( binary_image )

# Draw the contours for visualization

contour_image = np . ones_like ( binary_image ) * 255
contours , _ = cv2 . findContours ( binary_image , cv2 . RETR_EXTERNAL ,
cv2 . CH AI N _ AP P R OX _ S IM P L E )
if contours :
cv2 . drawContours ( contour_image , contours , -1 , 0 , 1)

# Display results
plt . figure ( figsize =(15 , 5) )

# Original RGB image

plt . subplot (1 , 3 , 1)
plt . imshow ( cv2 . cvtColor ( rgb_image , cv2 . COLOR_BGR2RGB ) )
plt . title ( " Original RGB Image " )
plt . axis ( ’ off ’)

# Binary image
plt . subplot (1 , 3 , 2)
plt . imshow ( binary_image , cmap = ’ gray ’)
plt . title ( " Binary Image " )
plt . axis ( ’ off ’)

# Contour image
plt . subplot (1 , 3 , 3)
plt . imshow ( contour_image , cmap = ’ gray ’)
plt . title ( " Contours from Freeman Chain Code " )
plt . axis ( ’ off ’)

25
 1.24. INTRODUCTIONCHAPITRE 1. SEGMENTATION DES IMAGES

# Print Freeman chain code

print ( " Freeman Chain Code : " , chain_code )

plt . show ()

26