Initiez-vous aux traitements de base des images numériques

Il s’agit d’un processus qui permet de séparer des objets qui sont collés.

Cette opération permet de supprimer des extrusions (ou aspérités).

Voici un autre exemple, avec un objet circulaire. On constate que le cercle après érosion est plus affiné. Concrètement, l’opération a permis de nettoyer la forme :

Définition :

Soit X un ensemble et B un élément structurant, l’érosion de X par B est donnée par :

ϵB(X)=X⊖B={x∈image|Bx⊂X}

• C'est-à-dire l’ensemble des points x de l'image, tels que B est totalement inclus dans X si B est centré en x.

Principe :

Partons d’un objet blanc sur fond noir et observons l’application de l’érosion sur cet exemple.

Ne perdons pas de vue que l’application de l’érosion sur un tel exemple avec l’élément structurant va réduire la taille de l’objet.

Algorithme :

Considérons 2 images :

• Image d’entrée =  ImaIn  (il s’agit de l’image brute) ;

• Image de sortie =  ImaOut  (il s’agit de l’image résultat).

Algorithme de l’érosion dans le cas d’images binaires :

Entrée : ImaIn  //Image à traiter
Sortie : ImaOut //Image traitée

// Principe de l'ÉROSION dans le cas d’images binaires
Début
    Pour tous les points ImaIn(x,y) Faire
        // calculer B ET (x,y) : le ET des voisins ;
        Si B ET (x,y) Alors
            ImaOut(x,y) = ImaIn(x,y);
        Sinon        
            ImaOut(x,y) = 0;
        FinSi
    FinPour
Fin

Il s'agit d'un processus qui permet de réparer des traits interrompus :

Cette opération permet aussi de combler les intrusions (ou trous) dans un objet :

Définition :

Soit X un ensemble et B un élément structurant, la dilatation de X par B est donnée par :

  δB(X)=X⊕B={x∈image|Bx∩X≠∅}  

•  C'est-à-dire l'ensemble des points x de l'image, tels que Bx a une intersection non vide avec X.

Remarque : autrement dit, la dilatation de X correspond donc à l'érosion du complémentaire de X.

Principe :

Partons d’un objet blanc sur fond noir et observons l’application de la dilatation sur cet exemple.

Ne perdons pas de vue que l’application de la dilatation sur un tel exemple avec l’élément structurant va agrandir la taille de l’objet.

Algorithme :

Entrée : ImaIn  // Image à traiter
Sortie : ImaOut // Image traitée

// Principe de la DILATATION dans le cas d’images binaires
Début
    Pour tous les points ImaIn(x,y) Faire
        // calculer B OU (x,y) : le OU des voisins ;
        Si B OU (x,y) Alors
            ImaOut(x,y) = 1;
        Sinon        
            ImaOut(x,y) = ImaIn(x,y);
        FinSi
    FinPour
Fin

Le code suivant utilise l'image  smiley_nb.png  que vous avez téléchargée dans le premier chapitre de cette partie.

Copiez-collez le chargement des modules nécessaires dans votre environnement Python :

#3_3 érosion et dilatation
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt

Ensuite, nous allons définir un algorithme générique de convolution. Ce code permet de calculer la valeur de chaque pixel d'une nouvelle image via l'application d'une fonction prenant en paramètre l'image, les coordonnées du pixel à calculer et un filtre à appliquer à ce pixel-là.

Copiez-collez ce code afin de créer cette fonction :

def convolution (image,filtre,function):
    new_image = np.zeros(image.shape,np.uint8)
    for i in range(0,image.shape[0]):
        for j in range(0,image.shape[1]):
            new_image[i,j] = function(image,i,j,filtre)
    return new_image

L'opération de dilatation correspond à une convolution particulière. Il nous faut donc coder la fonction correspondant à l'opération de dilatation sur un pixel donné. Comme indiqué auparavant, cette fonction revient à attribuer la valeur 1 à un pixel si au moins un pixel de son voisinage et son pixel correspondant dans l'élément structurant sont également égaux à 1.

def pixel_dilatation(image, ligne, colonne, elmt_structurant):
    width = elmt_structurant.shape[0] // 2
    height = elmt_structurant.shape[1] // 2
    pixel_value = False;
    for i in range(0,elmt_structurant.shape[0]):
        for j in range(0,elmt_structurant.shape[1]):
            x_image = ligne + i - width
            y_image = colonne + j - height
            if ((x_image >= 0) and (x_image < image.shape[0]) and
                (y_image>=0) and (y_image<image.shape[1])):
                if(... à compléter ...):
                    pixel_value = True
    return pixel_value

def pixel_erosion(image, ligne, colonne, elmt_structurant):
    width = elmt_structurant.shape[0] // 2
    height = elmt_structurant.shape[1] // 2
    pixel_value = True;
    for i in range(0,elmt_structurant.shape[0]):
        for j in range(0,elmt_structurant.shape[1]):
            x_image = ligne + i - width
            y_image = colonne + j - height
            if((x_image >= 0) and (x_image < image.shape[0]) and
               (y_image>=0) and (y_image<image.shape[1])):
                if(... à compléter ...):
                    pixel_value = False
    return pixel_value

Appliquez maintenant l'opérateur de dilatation et d'érosion sur l'image smiley_nb.png

image = cv.imread('smiley_nb.png',0)
plt.imshow(image,cmap='gray')
plt.show()

kernel_cross = cv.getStructuringElement(cv.MORPH_CROSS,(5,5))

plt.figure()
plt.imshow(erosion(image,kernel_cross),cmap='gray')
plt.title("Erosion")
plt.show()

plt.figure()
plt.imshow(dilatation(image,kernel_cross),cmap='gray')
plt.title("Dilatation")
plt.show()

Voici les images que vous devriez voir apparaître.

Après érosion :

Après dilatation :

Activité n° 3 - Érosion et dilatation

Réponse : la valeur correspond au nombre de lignes de l'image.

Réponse :

def pixel_dilatation(image, ligne, colonne, elmt_structurant):
    width = elmt_structurant.shape[0] // 2
    height = elmt_structurant.shape[1] // 2
    pixel_value = False;
    for i in range(0,elmt_structurant.shape[0]):
        for j in range(0,elmt_structurant.shape[1]):
            x_image = ligne + i - width
            y_image = colonne + j - height
            if ((x_image >= 0) and (x_image < image.shape[0]) and
                (y_image>=0) and (y_image<image.shape[1])):
                if(image[x_image,y_image] and elmt_structurant[i,j]):
                    pixel_value = True
    return pixel_value

La fonction de dilatation consiste ensuite à appliquer le filtre de convolution avec cette nouvelle fonction et un élément structurant.

def dilatation(image, elmt_structurant):

    return convolution(image,elmt_structurant,pixel_dilatation)

Réponse :

def pixel_erosion(image, ligne, colonne, elmt_structurant):

    width = elmt_structurant.shape[0] // 2
    height = elmt_structurant.shape[1] // 2
    pixel_value = True;

    for i in range(0,elmt_structurant.shape[0]):
        for j in range(0,elmt_structurant.shape[1]):
            x_image = ligne + i - width
            y_image = colonne + j - height

            if((x_image >= 0) and (x_image < image.shape[0]) and (y_image>=0) and (y_image<image.shape[1])):
                if (elmt_structurant[i,j] and not(image[x_image,y_image])):
                    pixel_value = False

return pixel_value

 Réponse :  cv.MORPH_RECT,(6,6))