INITIATION AU TRAITEMENT D'IMAGES avec NUMPY

La segmentation est l'opération qui permet de séparer une image en deux ensembles d'objets. Le critère de sélection est la valeur des pixels présents dans l'image. Le but étant de créer deux populations, nous allons séparer l'ensemble des pixels en deux ensembles distincts. Nous mettrons dans une population les pixels ayant pour valeurs des valeurs supérieures au seuil donné, ce sera la population blanche, ou objet. Dans l'autre population, nous mettrons les pixels ayant des valeurs inférieures au seuil donné, ce sera la population noire, ou fond. On peut exécuter un double seuillage, c'est-à-dire établir la population blanche étant la population répondant à deux critères de seuils. Par exemple la population blanche sera les pixels ayant une valeur inférieure au seuil 1 mais supérieure au seuil 2.

Je vais écrire un algorithme simple, mais qui nous permettra de bien comprendre le but recherché. Ensuite je décrirai les commandes permettant de mettre en œuvre le seuillage.

Faire ouvrir Image à seuiller
Créer nouveaux tableaux
Faire pour tout i dans l'image à seuiller
    regarder pixel[i]
    si pixel[i] inférieur seuil 1 et si pixel[i] supérieur seuil 2
        mettre tableau[i] à 1
    sinon mettre tableau[i] à zéro.
    Fin si
    Créer l'image résultat
Fin faire

Nous admettrons pour la suite du développement que la variable Img est le résultat de l'ouverture d'une image par la fonction OuvrirImg().

>>> Img = OuvrirImg("c:\\test.bmp")

Tout d'abord, je tiens à souligner que faire un seuillage sur test.bmp n'est pas judicieux, car il n'y a que deux valeurs de pixels. Donc les pixels sont déjà triés en deux populations. Une fois la fonction programmée, elle marchera pour les images en niveaux de gris. Je vais développer plusieurs solutions afin que vous puissiez voir comment on peut faire la même chose de façon différente. Pour commencer, nous allons construire le nouveau tableau. Comme vous avez pu le voir dans la FAQ, il existe plusieurs façons pour créer un tableau. Tout dépend de comment on veut procéder.

>>> tab=[0]*2 #crée une liste de 0 de longueur 2
>>> tab
[0, 0]

Il est peut-être judicieux d'utiliser la fonction append.

>>> tab.append(12)
>>> tab
[0, 0, 12]

Il faut se rendre compte d'une chose, notre image a deux dimensions. Pour le seuillage, travailler à une dimension est suffisant. Donc nous fabriquerons un tableau avec la fonction append. Vous aurez compris que nous travaillerons sur notre matrice au format « FLAT ». Nous utiliserons une boucle for pour parcourir les pixels. Nous ferons un test de comparaison des valeurs des pixels.

>>> Img = OuvrirImg("c:\\test.bmp")
>>> ImgF = list(Img.flat)
>>> SeuilHaut = 128
>>> SeuilBas = 25
>>> Tab = []
>>> for i in range(len(ImgF)):
        if ImgF[i]<SeuilBas and ImgF[i] > SeuilHaut: 
            Tab.append(1)
        else:Tab.append(0)
>>> print Tab

def Seuillage(img,seuil_B,seuil_H):
    imgF=list(img.flat)
    Threshold=[]
    for i in range(len(imgF)):
        if imgF[i] < seuil_H and imgF[i] > seuil_B:
            Threshold.append(1)
        else: Threshold.append(0)
    Threshold=numpy.array(Threshold)
    Threshold=Threshold.reshape(img.shape[0],img.shape[1])
    RebuildImg(Threshold*255,"c:\\seuillage.bmp")
    return Threshold

Ci-dessus est implémentée la fonction Seuillage(), j'ai quelques commentaires à faire sur certaines lignes. Dans l'algorithme nous avions vu que nous devions construire l'image résultante de notre traitement. Tout se passe dans cette ligne RebuildImg(Threshold*255,"c:\\seuillage.bmp"), nous multiplions les valeurs contenues dans Threshold par 255 pour l'affichage. En effet l'image Threshold est une image binaire, cela veut dire que ses valeurs sont comprises entre 0 et 1. Pour que les objets apparaissent en blanc, je multiplie donc le tableau par 255. Le return Threshold retourne un tableau de type binaire pour que l'on puisse faire des opérations booléennes dessus (ET, OU, UNION, etc., etc.).

Cependant, dans le souci du détail, Guigui_ m'a fait parvenir une façon de faire un seuillage 100 % NumPy et celui-ci est plus rapide.

import numpy

def seuillage(img, seuil, vbasse = 0, vhaute = 255):
    return numpy.where(img>= seuil, vhaute, vbasse)

Voilà, je pense que cela se passe de commentaire, la fonction where construit un array qui a pour valeur 255 lorsque les pixels sont supérieurs au seuil, sinon ils sont à zéro. Pour obtenir un objet plus « Booleen », remplacez 255 par 1.

J'ai effectué un seuillage de 125-250 sur l'image de lenna.GIF. Voici le résultat.
lenna.gif

seuillage.gif

La dilatation est avec l'érosion et quelques autres opérateurs, un opérateur de base en morphologie. Nous pouvons créer plusieurs filtres morphologiques avec la dilatation et l'érosion. L'érosion est une analogie de la dilatation, quand vous aurez compris la dilatation, il sera aisé pour vous de comprendre l'érosion. Admettons un ensemble d'objets. Posons-nous la question : « Est-ce qu'en le parcourant dans l'image mon élément structurant touche mon objet ? » La réponse positive à cette question s'appelle le DILATÉ de mon objet.
Qu'est-ce que l'élément structurant ?
L'élément structurant est un masque que nous faisons parcourir sur toute l'image. À chaque position, on se pose la question posée précédemment, sachant que la réponse sera appliquée à l'endroit où est centré l'objet.
Exemple avec un objet, un élément structurant carré 3x3 et deux positions de celui-ci :


Dans le premier cas : est-ce que l'élément structurant touche l'objet ?
Réponse : NON, donc le pixel sous le centre de l'élément structurant (case rouge) n'est pas un pixel du dilaté de l'objet.

Dans le deuxième cas : est-ce que l'élément structurant touche l'objet ?
Réponse : OUI, donc le pixel sous le centre de l'élément structurant appartient au dilaté de l'objet.

Nous avons vu les bases de la dilatation, mais lorsqu'il faut coder tout cela, on utilise une autre définition de la dilatation. En programmation, le dilaté d'un pixel c'est la valeur MAX au voisinage de ce pixel compris dans l'élément structurant. La définition citée plus haut ne marche que pour les images binaires, cependant, on peut dilater une image en niveaux de gris. La définition que je viens de citer fonctionne avec les images binaires comme en niveaux de gris.
Un autre problème intervient en programmation, c'est l'effet de bord. La gestion des bords en traitement d'images est assez subjective, pour certains comme pour la plupart des cas, nous supprimons les objets touchant les bords, la gestion des bords est alors une chose obsolète. Pour nous, la gestion des bords est respectée. Pour cela, nous allons agrandir notre image. Nous allons ajouter une bordure d'un pixel, car comme vous l'avez deviné, nous aurons des problèmes du genre index out of range.
Exemple d'une dilatation sur une matrice de nombres. RAPPEL DE DÉFINITION : le dilaté est la valeur MAX comprise au voisinage d'un pixel compris dans l'élément structurant.



La valeur surlignée est bien la valeur MAX comprise dans l'élément structurant. La valeur surlignée est bien le dilaté des valeurs à cet endroit.

Ouvrir Image à Dilater            
Ajouter une bordure à l'image pour gérer l'effet de bord
Créer un nouveau tableau pour stocker les résultats de la taille de l'image ORIGINALE
x=largeur de l'image+bordure
y=hauteur de l'image+bordure
pour tous les i allant de 1 à x-1:
    pour tous les j allant de 1 à j-1:
        tableau[i-1][j-1]=max(voisinage 3x3 de ce pixel)
Reconstruire l'image dilatée

Pour gérer les bords, nous allons créer une fonction. Mais quel type de pixels allons-nous mettre dans cette bordure ? Nous allons mettre des pixels NOIRS, car ils n'interagiront pas avec les valeurs.

                              0,0,0,0,0
1,1,1                         0,1,1,1,0
1,1,1    --->fonction()---->  0,1,1,1,0
1,1,1                         0,1,1,1,0
                              0,0,0,0,0

Pour cela, il suffit de créer un tableau de dimensions (x+2,y+2).

Ouvrir Image à dilater
Créer un tableau (x+2,y+2) rempli de 0
Pour i de 1 à x-1:
    Pour j de 1 à y-1:
        tableau[i][j]=Image[i-1][j-1]
    fin Pour
fin Pour

Faire DILATATION

Voici la fonction bord().

def Bord(data):
    data=numpy.array(data)
    x=data.shape[1]+2
    y=data.shape[0]+2
    new=[x*[0]]*y  #création du tableau
    new=numpy.array(new)
    
    h=1
    for i in range(1,y-1):
        for j in range(1,x-1):
            new[i][j]=data[i-1][j-1] #remplissage du tableau
            
    return new

Il suffit maintenant de parcourir ce tableau de 1 à x-1 et de 1 à y-1, de regarder dans un voisinage 3x3 les valeurs et appliquer la valeur max au point d'ancrage de l'élément structurant.
Voici la fonction dilatation()

def Dilatation(img):
    
    Dilate=[0]*(img.shape[1]-2)*(img.shape[0]-2)
    h=0
    for i in range(1,img.shape[0]-1):
        for j in range(1,img.shape[1]-1):
           Dilate[h]=max([img[i-1][j-1],img[i][j-1],img[i+1][j-1],img[i-1][j],img[i][j],img[i+1][j],img[i-1][j+1],img[i][j+1],img[i+1][j+1]]) 
           #Mise de la valeur max du voisinage 3x3 au point(x,y)
           h+=1
    
    Dilate=numpy.array(Dilate)
    Dilate=numpy.reshape(Dilate,(img.shape[0]-2,img.shape[1]-2))
    RebuildImg(Dilate,"c:\\dilate.bmp")

Voilà, nous avons programmé la dilatation. Pour l'érosion vous verrez que très peu de changements sont à apporter.

>>> a = OuvrirImg("c:\\bob.bmp")
>>> b = Bord(a)
>>> c = Dilatation(b)

bob.bmp

bob dilaté

bob seuillé 128-255

bob seuillé puis dilaté



On voit bien que les objets en blanc gagnent du « terrain » alors que les objets en noir en perdent. Nous avons dilaté.

Comme je l'ai dit précédemment, l'érosion est un opérateur de base en traitement d'image. Je pense que vous avez compris ce qu'est la DILATATION, alors je ne vais pas m'étendre et me perdre dans les définitions complexes. Rappelez-vous que nous nous posions une question pour savoir si un pixel appartenait au dilaté de cet objet. Il existe une question pour l'érosion.
Admettons un ensemble d'objets.
Posons-nous la question : est-ce que mon élément structurant est complètement inclus dans mon objet ?
Les réponses positives constitueront l'érodé de l'objet.



Dans le premier cas, posons-nous la question : est-ce que l'élément structurant est complètement inclus dans mon objet ?

• Dans le premier cas, la réponse est négative.
• Dans le second, elle est positive, donc le pixel situé sous le centre de l'élément structurant sera mis à 1. C'est aussi simple que cela.

Comme pour la dilatation, il existe une astuce pour calculer l'érodé d'un objet. Pour la dilatation, nous prenions le max dans un voisinage 3x3, pour l'érosion nous prendrons le minimum dans un voisinage 3x3. Pour la gestion des bords, nous aurons une fonction bord2 proche de la fonction bord sauf que l'on ajoutera un bord de pixels blancs pour qu'il ne fausse pas le résultat.

def Bord2(data):
    data=numpy.array(data)
    x=data.shape[1]+2
    y=data.shape[0]+2
    new=[x*[1]]*y  #création du tableau
    new=numpy.array(new)
    
    h=1
    for i in range(1,y-1):
        for j in range(1,x-1):
            new[i][j]=data[i-1][j-1] #remplissage du tableau
            
    return new

Voici le code de l'érosion.

def Erosion(img):
    
    Erode=[0]*(img.shape[1]-2)*(img.shape[0]-2)
    h=0
    for i in range(1,img.shape[0]-1):
        for j in range(1,img.shape[1]-1):
           Erode[h]=min([img[i-1][j-1],img[i][j-1],img[i+1][j-1],img[i-1][j],img[i][j],img[i+1][j],img[i-1][j+1],img[i][j+1],img[i+1][j+1]]) 
           #Mise de la valeur max du voisinage 3x3 au point(x,y)
           h+=1
    
    Erode=numpy.array(Erode)
    Erode=numpy.reshape(Erode,(img.shape[0]-2,img.shape[1]-2))
    RebuildImg(Erode,"c:\\erode.bmp")

Voilà l'érosion est programmée. C'est très similaire à la dilatation à quelques détails près.

>>> a = OuvrirImg("c:\\bob.bmp")
>>> b = Bord2(a)
>>> c = Erosion(b)

bob.bmp

bob érodé