Filtrage d’images avec Machine Learning

Découvrez comment appliquer des filtres aux photos en utilisant le langage Python.

29 octobre 2022

0 2 465

Le filtrage d’image est utilisé pour améliorer les contours des images et réduire le bruit d’une image. Cette technologie est utilisée dans presque tous les smartphones. Bien que l’amélioration d’une image à l’aide des techniques de filtrage d’image puisse aider dans le processus de détection d’objets, de reconnaissance faciale et de toutes les tâches impliquées dans la vision par ordinateur. Dans cet article, je vais vous présenter quelques méthodes de filtrage d’images avec Machine Learning à l’aide de Python.

Sommaire

Filtrage d’image à l’aide du filtre moyen

Le filtre moyen est utilisé pour donner un effet de flou à une image afin de supprimer le bruit existant. Il détermine la moyenne des pixels dans la méthode n×n. Ensuite, il remplace l’intensité des pixels par la moyenne. Cela réduit une partie du bruit présent dans l’image et améliore également les bords d’une image.

Passons en revue le filtrage d’image en utilisant la méthode du filtre moyen ; Je vais commencer par importer toutes les bibliothèques et une photo d’une personnage, pour explorer les techniques de filtrage d’images en Machine Learning.

import numpy as np
import cv2
from matplotlib import pyplot as plt
from PIL import Image, ImageFilter
%matplotlib inline
image = cv2.imread('cm.jpg') # reads the image
image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) # convert to HSV
figure_size = 9 # the dimension of the x and y axis of the kernal.
new_image = cv2.blur(image,(figure_size, figure_size))
plt.figure(figsize=(11,6))
plt.subplot(121), plt.imshow(cv2.cvtColor(image, cv2.COLOR_HSV2RGB)),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(cv2.cvtColor(new_image, cv2.COLOR_HSV2RGB)),plt.title('Mean filter')
plt.xticks([]), plt.yticks([])
plt.show()

La figure ci-dessus montre qu’une partie du bruit a été réduite, mais il y a maintenant des marques qui n’étaient pas présentes dans l’image auparavant. Voyons si ces marques apparaissent toujours si nous filtrons l’image en niveaux de gris :

# The image will first be converted to grayscale
image2 = cv2.cvtColor(image, cv2.COLOR_HSV2BGR)
image2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
figure_size = 9
new_image = cv2.blur(image2,(figure_size, figure_size))
plt.figure(figsize=(11,6))
plt.subplot(121), plt.imshow(image2, cmap='gray'),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(new_image, cmap='gray'),plt.title('Mean filter')
plt.xticks([]), plt.yticks([])
plt.show()

Donc, comme vous pouvez le voir après l’avoir filtré en niveaux de gris, les marques n’apparaissent plus, cependant, nous avons perdu une certaine douceur de l’image. Je le réparerai bientôt en utilisant un autre filtre.

Filtrage d’image à l’aide du filtre gaussien

Le filtre gaussien est très similaire au filtre moyen, mais il s’agit d’une moyenne pondérée des pixels avec un paramètre comme sigma. Passons en revue cette méthode de filtrage d’image :

new_image = cv2.GaussianBlur(image, (figure_size, figure_size),0)
plt.figure(figsize=(11,6))
plt.subplot(121), plt.imshow(cv2.cvtColor(image, cv2.COLOR_HSV2RGB)),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(cv2.cvtColor(new_image, cv2.COLOR_HSV2RGB)),plt.title('Gaussian Filter')
plt.xticks([]), plt.yticks([])
plt.show()

La figure ci-dessus représente un bon travail par rapport au filtre moyen, bien qu’elle laisse également quelques marques que nous avons vues dans le filtre moyen. Voyons maintenant si le filtre gaussien supprime les marques lorsqu’il est converti en niveaux de gris :

new_image_gauss = cv2.GaussianBlur(image2, (figure_size, figure_size),0)
plt.figure(figsize=(11,6))
plt.subplot(121), plt.imshow(image2, cmap='gray'),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(new_image_gauss, cmap='gray'),plt.title('Gaussian Filter')
plt.xticks([]), plt.yticks([])
plt.show()

Comme vous pouvez le voir, les marques sont supprimées dans l’effet de niveaux de gris. Passons maintenant à la méthode suivante de filtrage d’images.

Filtrage d’image à l’aide du filtre médian

Le filtre médian calcule la médiane de l’intensité des pixels. Il remplace ensuite la norme par l’intensité de pixel des pixels moyens. Passons maintenant à cette technique :

new_image = cv2.medianBlur(image, figure_size)
plt.figure(figsize=(11,6))
plt.subplot(121), plt.imshow(cv2.cvtColor(image, cv2.COLOR_HSV2RGB)),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(cv2.cvtColor(new_image, cv2.COLOR_HSV2RGB)),plt.title('Median Filter')
plt.xticks([]), plt.yticks([])
plt.show()

L’effet médian laisse un meilleur rendu en supprimant le bruit de l’image. Il n’a pas non plus laissé de marques dans l’image que nous avons vue dans les méthodes ci-dessus. Convertissons-le maintenant en une image en niveaux de gris :

new_image = cv2.medianBlur(image2, figure_size)
plt.figure(figsize=(11,6))
plt.subplot(121), plt.imshow(image2, cmap='gray'),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(new_image, cmap='gray'),plt.title('Median Filter')
plt.xticks([]), plt.yticks([])
plt.show()

Nous pouvons voir dans la sortie que le filtre médian a supprimé le bruit et a également conservé les bords lorsqu’il est converti en une image en niveaux de gris. Créons maintenant notre propre filtre.

Créons notre propre filtre

Maintenant, je vais créer notre propre filtre pour filtrer les images qui peut améliorer la qualité de l’image et améliorer la fluidité de l’image. Je vais d’abord créer une fonction pour concevoir mon propre filtre d’image :

def aman_effect(data, filter_size):
temp = []
indexer = filter_size // 2
new_image = data.copy()
nrow, ncol = data.shape
for i in range(nrow):
  for j in range(ncol):
    for k in range(i-indexer, i+indexer+1):
      for m in range(j-indexer, j+indexer+1):
        if (k &gt; -1) and (k &lt; nrow):
          if (m &gt; -1) and (m &lt; ncol):
    temp.append(data[k,m])
    temp.remove(data[i,j])
    max_value = max(temp)
    min_value = min(temp)
    if data[i,j] &gt; max_value:
      new_image[i,j] = max_value
    elif data[i,j] &lt; min_value:
      new_image[i,j] = min_value
      temp =[]
return new_image.copy()

Utilisons maintenant notre filtre pour améliorer la qualité de l’image en niveaux de gris :

new_image = aman_effect(image2,5)
plt.figure(figsize=(11,6))
plt.subplot(121), plt.imshow(image2, cmap='gray'),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(new_image, cmap='gray'),plt.title('Image Filteration')
plt.xticks([]), plt.yticks([])
plt.show()

Dans la sortie, vous pouvez voir que nous avons une excellente sortie par rapport à presque toutes les méthodes que j’ai décrites ci-dessus. J’espère que cela vous aidera à explorer le domaine de la vision par ordinateur dans l’apprentissage automatique. J’espère que vous avez aimé cet article sur le filtrage d’images avec l’apprentissage automatique. N’hésitez pas à poser vos précieuses questions dans la section des commentaires ci-dessous.