Le traitement d'image ne fournit pas toujours de belles images. L'image est souvent bruyante. S'il y a du bruit, il peut être éliminé en utilisant une technique appelée «lissage» ou «conversion de morphologie».
Cette fois, nous utiliserons Python pour effectuer la conversion morphologique de l'image par OpenCV.
** La conversion morphologique ** consiste principalement à effectuer des traitements de «** contraction » et « expansion **» sur des images binaires. La morphologie est un processus lié à la «morphologie», c'est-à-dire à la forme.
Une "image binaire" est une image binarisée. La binarisation est le processus de conversion d'une image en deux gradations, blanc et noir.
L'environnement utilise Google Colaboratory. La version Python est ci-dessous.
import platform
print("python " + platform.python_version())
# python 3.6.9
Maintenant écrivons le code. Tout d'abord, importez OpenCV.
import cv2
De plus, importez les éléments suivants pour afficher l'image dans Colaboratory.
from google.colab.patches import cv2_imshow
Préparez également un exemple d'image.
Maintenant, affichons l'exemple d'image préparé.
img = cv2.imread(path) #chemin spécifie où l'image est placée
cv2_imshow(img)
L'image en niveaux de gris est ci-dessous.
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2_imshow(img_gray)
L'image binarisée de l'image en niveaux de gris est la suivante. Cette fois, j'ai mis le seuil à 180.
threshold = 180
_, img_th = cv2.threshold(img_gray, threshold, 255, cv2.THRESH_BINARY)
cv2_imshow(img_th)
De plus, affichons une image inversée en noir et blanc de l'image binarisée. J'effectuerai une conversion de morphologie sur cette image.
img_bw = cv2.bitwise_not(img_th)
cv2_imshow(img_bw)
De plus, préparez une image avec du bruit comme image à utiliser ultérieurement. Cette fois, j'ai préparé deux types d'images avec du bruit en utilisant le bruit sel et poivre.
import numpy as np
row, col, ch = img.shape
img_s = img.copy()
img_p = img.copy()
pts_x = np.random.randint(0, col-1 , 1000)
pts_y = np.random.randint(0, row-1 , 1000)
img_s[(pts_y,pts_x)] = (255, 255, 255)
img_p[(pts_y,pts_x)] = (0, 0, 0)
imgs = cv2.hconcat([img_s, img_p])
cv2_imshow(imgs)
Ces images doivent également être en niveaux de gris, binarisées et inversées en noir et blanc.
#niveaux de gris
img_s = cv2.cvtColor(img_s, cv2.COLOR_BGR2GRAY)
img_p = cv2.cvtColor(img_p, cv2.COLOR_BGR2GRAY)
#Binarisation
threshold = 180
_, img_s = cv2.threshold(img_s, threshold, 255, cv2.THRESH_BINARY)
_, img_p = cv2.threshold(img_p, threshold, 255, cv2.THRESH_BINARY)
#Inversion noir et blanc
img_s = cv2.bitwise_not(img_s)
img_p = cv2.bitwise_not(img_p)
imgs = cv2.hconcat([img_s, img_p])
cv2_imshow(imgs)
Maintenant, introduisons comment effectuer une conversion de morphologie sur une image.
Importez numpy à l'avance pour une utilisation dans ce qui suit.
import numpy as np
Avec l'érosion, ** rétrécissez les zones blanches **. En conséquence, les zones blanches deviennent de plus en plus petites et les zones noires augmentent. Il s'agit d'un processus efficace pour supprimer le bruit blanc d'une image ou séparer plusieurs objets connectés.
Maintenant, affichons l'image rétrécie côte à côte avec l'image d'origine.
kernel = np.ones((3, 3), np.uint8)
img_ero = cv2.erode(img_bw, kernel, iterations=1)
imgs = cv2.hconcat([img_bw, img_ero])
cv2_imshow(imgs)
Vous pouvez voir que la partie blanche est plus petite et plus fine que l'image d'origine.
Il existe trois arguments pour cv2.erode. Le premier argument est l'image cible. Le deuxième argument est appelé la taille du noyau. Lorsqu'un point de l'image est décidé, cela montre combien de zone autour de lui est incluse. Considérez-le comme la taille d'une boîte. Le troisième argument est ce qu'on appelle une itération. Itération signifie «itération», et ici vous spécifiez combien de fois le processus doit être exécuté. Dans ce qui précède, le processus de contraction n'est effectué qu'une seule fois.
Maintenant, affichons l'image traitée par réduction en modifiant la valeur de la taille du noyau de différentes manières.
kernel_1 = np.ones((1, 1), np.uint8)
kernel_2 = np.ones((3, 3), np.uint8)
kernel_3 = np.ones((5, 5), np.uint8)
img_1 = cv2.erode(img_bw, kernel_1, iterations=1)
img_2 = cv2.erode(img_bw, kernel_2, iterations=1)
img_3 = cv2.erode(img_bw, kernel_3, iterations=1)
imgs = cv2.hconcat([img_1, img_2, img_3])
cv2_imshow(imgs)
Vous pouvez voir que plus la taille du noyau est grande, plus elle rétrécit et les zones blanches deviennent de plus en plus fines.
Ensuite, affichons l'image traitée par réduction en modifiant la valeur d'itération de différentes manières.
kernel = np.ones((3, 3), np.uint8)
img_1 = cv2.erode(img_bw, kernel, iterations=1)
img_2 = cv2.erode(img_bw, kernel, iterations=3)
img_3 = cv2.erode(img_bw, kernel, iterations=5)
imgs = cv2.hconcat([img_1, img_2, img_3])
cv2_imshow(imgs)
Là encore, le processus de rétrécissement est répété pour le nombre d'itérations, donc plus la valeur est élevée, plus le rétrécissement est important.
La dilatation ** dilate les zones blanches **. C'est l'inverse de la contraction. En d'autres termes, en conséquence, les zones noires deviennent de plus en plus fines et les zones blanches augmentent.
Maintenant, affichons l'image développée côte à côte avec l'image d'origine.
img_dil = cv2.dilate(img_bw, kernel, iterations = 1)
imgs = cv2.hconcat([img_bw, img_dil])
cv2_imshow(imgs)
Vous pouvez voir que la partie blanche est plus épaisse et plus grande que l'image d'origine.
Les arguments de cv2.dilate sont similaires aux arguments de contraction cv2.erode.
Le processus d'ouverture est le processus d'expansion après la conclusion d'un contrat. La partie blanche peut être réduite en rétrécissant, et la taille peut être restaurée en agrandissant. Par conséquent, il s'agit d'un processus efficace pour éliminer le ** bruit blanc **.
Montrons l'image avec du bruit et l'image avec le processus d'ouverture côte à côte.
img_opening = cv2.morphologyEx(img_p, cv2.MORPH_OPEN, kernel)
imgs = cv2.hconcat([img_p, img_opening])
cv2_imshow(imgs)
À la suite du processus d'ouverture, vous pouvez voir que le bruit blanc a été supprimé.
Le processus de clôture est l'inverse du processus d'ouverture. La partie noire peut être réduite par expansion et la taille peut être restaurée par contraction. Par conséquent, c'est un processus efficace pour éliminer le ** bruit noir **.
Montrons l'image avec du bruit et l'image avec le traitement de fermeture côte à côte.
img_closing = cv2.morphologyEx(img_s, cv2.MORPH_CLOSE, kernel)
imgs = cv2.hconcat([img_s, img_closing])
cv2_imshow(imgs)
À la suite du processus de fermeture, vous pouvez voir que le bruit noir a été supprimé.
Le gradient de morphologie est le processus consistant à faire la différence entre une image agrandie et une image contractée. Cela entraînera le contour de l'objet.
Affichons une image avec un dégradé de morphologie.
img_gradient = cv2.morphologyEx(img_bw, cv2.MORPH_GRADIENT, kernel)
cv2_imshow(img_gradient)
Vous pouvez voir que le contour de l'objet est pris.
Cette fois, j'ai utilisé Python pour effectuer une conversion morphologique de l'image par OpenCV.
En tant que conversion de morphologie, nous avons introduit la «contraction», «l'expansion», «processus d'ouverture», «processus de fermeture» et «gradient de morphologie». En particulier, le processus d'ouverture et le processus de fermeture sont des méthodes efficaces pour éliminer les bruits fins. Envisagez un traitement d'ouverture pour le bruit blanc et un traitement de fermeture pour le bruit noir.
Il existe également une méthode appelée "lissage" comme méthode d'élimination du bruit, donc je pense que vous devriez également essayer ceci.
Voir ci-dessous pour plus d'informations sur les transformations morphologiques et le lissage.
Recommended Posts