Filtres de flou dans OpenCV

Cette démonstration présentera comment lisser ou flouter des images dans OpenCV. Nous discuterons des différents types de filtres de flou et de leur utilisation à la fin de cet article.

Utiliser différents types de filtres de flou dans OpenCV

Le lissage, également appelé floutage, est l’une des opérations les plus couramment utilisées dans le traitement d’images. Il est couramment utilisé pour supprimer le bruit des images.

Nous pouvons utiliser divers filtres linéaires car les filtres linéaires sont faciles à réaliser et relativement rapides. Il existe différents types de filtres disponibles dans OpenCV, par exemple des filtres homogènes, gaussiens, médians ou bilatéraux, que nous verrons individuellement.

Tout d’abord, nous allons voir le filtre homogène. Le filtre homogène est simple et chaque pixel de sortie est la moyenne de ses voisins du noyau dans un filtre homogène.

Tous les pixels contribuent avec un poids égal, c’est pourquoi ils sont appelés filtres homogènes. En d’autres termes, le noyau est une forme que nous pouvons appliquer ou convoluer sur une image.

Le numpy crée ce genre de noyau au carré. Ainsi, dans un filtre homogène, le noyau ressemble à cette image.

Dans le filtre homogène, le noyau K est égal à 1 divisé par la largeur du noyau multiplié par la hauteur du noyau. Si nous voulons utiliser un noyau de 5 sur 5 en utilisant cette formule, alors nous aurons K égal à 1 divisé par 25, et nous aurons une matrice de noyau 5 sur 5 de 1.

Maintenant, nous devons créer ce noyau pour le filtrage d’image en utilisant filter2D() ou le filtre homogène. Dans un premier temps, nous allons lire une image en utilisant la méthode imread().

IMG = cv2.imread("opencv-logo.jpg")

Nous devons convertir l’image de BGR en RVB car matplotlib lit les images au format RVB et OpenCV lit les images au format BGR.

IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

Nous devons définir un noyau 5x5 en utilisant la méthode ones() avec le type de données float32, et nous le diviserons par 25.

K = np.ones((5, 5), np.float32) / 25

Maintenant, nous pouvons définir notre image de destination en assistant le noyau défini. Une méthode appelée filter2D() est utilisée pour le filtre homogène.

Le premier paramètre sera l’image source, le second la profondeur souhaitée de l’image de destination et le troisième le noyau.

HMG = cv2.filter2D(IMG, -1, K)

Dans la ligne suivante, nous itérons une boucle for, et nous afficherons des images sur matplotlib au format 1 par 2 à travers cette boucle.

for j in range(2):
    plot.subplot(1, 2, j + 1), plot.imshow(IMGS[j], "gray")

Exemple complet de code source :

import numpy as np
import matplotlib.pyplot as plot

IMG = cv2.imread("opencv-logo.jpg")
IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

K = np.ones((5, 5), np.float32) / 25
HMG = cv2.filter2D(IMG, -1, K)


T = ["Original IMG", "2D Convolution"]
IMGS = [IMG, HMG]

for j in range(2):
    plot.subplot(1, 2, j + 1), plot.imshow(IMGS[j], "gray")
    plot.title(T[j])
    plot.xticks([]), plot.yticks([])

plot.show()

On peut voir un peu de bruit dans les coins, et après application de la convolution 2D sur cette image, les coins sont légèrement lissés ou flous. Les bruits sont supprimés ou supprimés par ce flou, c’est donc une façon de flouter une image en utilisant la méthode filter2D().

Filtre de flou

Les images unidimensionnelles peuvent être filtrées avec des filtres passe-bas ou des filtres passe-haut. Le filtre passe-bas aide à éliminer le bruit ou le flou de l’image, etc., et le filtre passe-haut aide à trouver les contours des images.

Pour obtenir une image floue, vous devez convertir l’image avec le filtre passe-bas. Différents types d’algorithmes sont disponibles dans OpenCV ; le premier algorithme est la méthode blur().

La méthode blur() est également appelée méthode de calcul de la moyenne, que nous utiliserons pour appliquer l’algorithme de calcul de la moyenne afin de rendre l’image floue. Cette méthode prend deux paramètres : le premier est l’image, et le second est le noyau, qui sera (5,5).

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

IMG = cv2.imread("opencv-logo.jpg")
IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

K = np.ones((5, 5), np.float32) / 25
HMG = cv2.filter2D(IMG, -1, K)
BL = cv2.blur(IMG, (5, 5))

T = ["Original IMG", "2D Convolution", "Blur"]
IMGS = [IMG, HMG, BL]

for j in range(3):
    plot.subplot(1, 3, j + 1), plot.imshow(IMGS[j], "gray")
    plot.title(T[j])
    plot.xticks([]), plot.yticks([])

plot.show()

Le résultat, plus ou moins, semble le même entre la convolution 2D et le flou car nous avons appliqué le même type de noyau aux deux fonctions.

Filtre Gaussien

Voyons l’algorithme suivant, qui est l’algorithme du filtre gaussien. Le filtre gaussien n’est rien d’autre qu’un noyau de poids différent dans les directions x et y.

Dans la sortie, les pixels sont situés au milieu du noyau avec un poids supérieur ou supérieur. Les poids diminuent avec la distance au centre du quartier.

Les pixels de plus petit poids sont situés sur le côté et les pixels de poids plus élevé sont situés au centre.

Lorsque nous prenons un noyau 5x5, son résultat ressemblera à celui montré dans l’image.

Voyons comment utiliser la méthode GaussianBlur() dans OpenCV. Les paramètres sont les mêmes que la méthode blur(), donc le premier paramètre est l’image d’entrée, le second est notre noyau, et le troisième est la valeur Sigma X.

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

IMG = cv2.imread("eye.jpg")
IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

K = np.ones((5, 5), np.float32) / 25
HMG = cv2.filter2D(IMG, -1, K)
BL = cv2.blur(IMG, (5, 5))
GB = cv2.GaussianBlur(IMG, (5, 5), 0)

T = ["Original IMG", "2D Convolution", "Blur", "GaussianBlur"]
IMGS = [IMG, HMG, BL, GB]

for j in range(4):
    plot.subplot(2, 2, j + 1), plot.imshow(IMGS[j], "gray")
    plot.title(T[j])
    plot.xticks([]), plot.yticks([])

plot.show()

Nous pouvons observer que le résultat de la méthode GaussianBlur() est meilleur que les autres méthodes de floutage.

Regardez l’image originale, qui a trop de bruit. Tout le bruit est supprimé après application de la méthode GaussianBlur().

Ainsi, la méthode GaussianBlur() est spécifiquement conçue pour supprimer le bruit haute fréquence d’une image.

Filtre médian

Le filtre médian est quelque chose qui remplace chaque valeur de pixel par la médiane de son pixel voisin. La méthode medianBlur() est idéale lorsqu’il s’agit d’une image avec un bruit poivre et sel.

Si vous voulez en savoir plus sur le bruit poivre et sel, suivez ce lien.

Nous avons ici une image; certains pixels sont déformés, certains sont les points blancs ou le bruit blanc, et certains sont là où le bruit noir est visible. Parce que les pixels sont déformés comme du sel et que les pixels noirs ressemblent à du poivre, on parle de bruit poivre et sel.

Utilisons cette image comme source dans la méthode medianBlur(). L’image source sera le premier paramètre, et le second sera la taille du noyau.

Nous devons noter que la taille du noyau doit être impaire, comme 3, 5, 7, etc., sauf 1. Si vous utilisez 1, il vous montrera l’image d’origine.

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

IMG = cv2.imread("water.jpg")
IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

K = np.ones((5, 5), np.float32) / 25
HMG = cv2.filter2D(IMG, -1, K)
BL = cv2.blur(IMG, (5, 5))
GB = cv2.GaussianBlur(IMG, (5, 5), 0)
MB = cv2.medianBlur(IMG, 5)

T = ["Original IMG", "2D Convolution", "Blur", "GaussianBlur", "medianBlur"]
IMGS = [IMG, HMG, BL, GB, MB]

for j in range(5):
    plot.subplot(2, 3, j + 1), plot.imshow(IMGS[j], "gray")
    plot.title(T[j])
    plot.xticks([]), plot.yticks([])

plot.show()

Nous voyons ci-dessous le meilleur résultat que nous obtenons en utilisant la méthode medianBlur().

Filtre bilatéral

Voyons le dernier filtre, qui s’appelle le filtre bilatéral. Ainsi, en utilisant d’autres filtres, nous avons non seulement dissous le bruit, mais également lissé les bords.

Parfois, nous devons préserver les bords, ce qui signifie que tous les bords restent nets même si l’image est floue.

La méthode bilateralFilter() prend l’image comme premier paramètre. Le deuxième paramètre est le diamètre de chaque pixel utilisé lors du filtrage, le troisième paramètre est la couleur Sigma et le quatrième est l’espace Sigma.

La couleur Sigma est le filtre Sigma dans l’espace colorimétrique et l’espace Sigma est le filtre Sigma dans l’espace des coordonnées.

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

IMG = cv2.imread("lena-1.jpg")
IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

K = np.ones((5, 5), np.float32) / 25
HMG = cv2.filter2D(IMG, -1, K)
BL = cv2.blur(IMG, (5, 5))
GB = cv2.GaussianBlur(IMG, (5, 5), 0)
MB = cv2.medianBlur(IMG, 5)
BF = cv2.bilateralFilter(IMG, 9, 75, 75)

T = [
    "Original IMG",
    "2D Convolution",
    "Blur",
    "GaussianBlur",
    "medianBlur",
    "bilateralFilter",
]
IMGS = [IMG, HMG, BL, GB, MB, BF]
plot.figure(figsize=(8, 6))
for j in range(6):
    plot.subplot(2, 3, j + 1), plot.imshow(IMGS[j], "gray")
    plot.title(T[j])
    plot.xticks([]), plot.yticks([])

plot.show()

Regardez comment les bords sont bien mieux préservés lorsque la méthode bilateralFilter() est appliquée. Le filtre bilatéral est très efficace pour éliminer le bruit tout en gardant les bords nets.