Traitement d'images Partie 5 : Arithmétique, logique binaire et masquage

Dans cette cinquième partie de la série sur le traitement d'images, nous discutons davantage des opérations arithmétiques et bitwise, ainsi que du masquage des images en Python.

Il est recommandé de passer en revue les articles précédents avant de commencer votre aventure d'apprentissage masqué ici.

Configuration de l'environnement

Les lignes de code suivantes sont utilisées dans toutes les applications données ci-dessous. Nous les inclurons ici afin que vous n'ayez pas à lire un énorme bloc de code.

Aide à réduire le désordre :)

importing numpy to work with pixels
import numpy as np

importing argument parsers
import argparse

importing the OpenCV module
import cv2


initializing an argument parser object
ap = argparse.ArgumentParser()

adding the argument, providing the user an option
to input the path of the image
ap.add_argument("-i", "--image", required=True, help="Path to the image")

parsing the argument
args = vars(ap.parse_args())

reading the image location through args
and reading the image using cv2.imread
image = cv2.imread(args["image"])

Opérations arithmétiques sur les images utilisant Python

Les opérations arithmétiques nous permettent d'améliorer de nombreux aspects d'une image.

Nous pouvons travailler avec l'éclairage, les ombres, l'amélioration des couleurs rouge, bleu et vert.

De nombreuses filtres d'image sur les applications utilisent la même méthode pour altérer et embellir les photographies aussi.

Alors, commençons avec tout le code !

Tout d'abord, afin de comprendre si la limite peut dépasser 255 ou 0, nous pouvons effectuer un test simple, qui nous fournit 255 et 0.

printing out details of image min, max and the wrap around
print("max of 255 :", str(cv2.add(np.uint8([200]), np.uint8([100]))))
print("min of 0 :", str(cv2.subtract(np.uint8([50]), np.uint8([100]))))

print("wrap around :", str(np.uint8([200]) + np.uint8([100])))
print("wrap around :", str(np.uint8([50]) - np.uint8([100])))

Dans cet exemple, nous augmentons l'intensité de tous les pixels de l'image de 100.

adding pixels of value 255 (white) to the image
M = np.ones(image.shape, dtype="uint8") * 100
added = cv2.add(image, M)
cv2.imshow("Added", added)
cv2.waitKey(0)

Ceci est réalisé en construisant une matrice de la même taille que nos images en utilisant le module NumPy, et en l'ajoutant à notre image.

Dans le cas où nous souhaitons dessombrer une image, nous soustrayons aux valeurs des pixels de l'image, comme indiqué ci-dessous,

adding pixels of value 0 (black) to the image
M = np.ones(image.shape, dtype="uint8") * 50
subtracted = cv2.subtract(image, M)
cv2.imshow("Subtracted", subtracted)
cv2.waitKey(0)

Cela devrait vous fournir deux variations différentes de l'image originale, l'une plus claire et l'autre plus sombre.

Opérations bit à bit

Nous utilisons souvent des opérations bit à bit lorsque nous essayons de masquer des images.

Cette fonctionnalité d'OpenCV nous permet de filtrer la partie de l'image qui est pertinente pour nous.

Configuration

Pour travailler sur les opérations bit à bit, nous aurons d'abord besoin de deux variables ou images sur lesquelles nous pouvons effectuer les opérations.

Donc, créons un carré binaire et un cercle binaire à travers lesquels nous pouvons utiliser les opérations binaires.

Notez que les opérations bit à bit nécessitent que les images soient en noir et blanc.

creating a square of zeros using a variable
rectangle = np.zeros((300, 300), dtype="uint8")
cv2.rectangle(rectangle, (25, 25), (275, 275), 255, -1)
cv2.imshow("Rectangle : ", rectangle)

creating a circle of zeros using a variable
circle = np.zeros((300, 300), dtype="uint8")
cv2.circle(circle, (150, 150), 150, 255, -1)
cv2.imshow("Circle : ", circle)

Les images de sortie que vous recevez devraient ressembler à ceci,

Combinez avec l'opération AND

L'addition bit à bit fait référence à l'addition de deux images différentes et détermine laquelle doit être affichée en utilisant une opération ET sur chaque pixel des images.

the bitwise_and function executes the AND operation
on both the images
bitwiseAnd = cv2.bitwise_and(rectangle, circle)
cv2.imshow("AND", bitwiseAnd)
cv2.waitKey(0)

L'addition bit à bit du cercle et du carré nous donne un résultat qui devrait ressembler à ceci,

Étant donné un choix avec l'opération OU

L'OR bit à bit nous fournit un produit des deux images avec une opération OR effectuée sur chaque pixel des images.

the bitwise_or function executes the OR operation
on both the images
bitwiseOr = cv2.bitwise_or(rectangle, circle)
cv2.imshow("OR", bitwiseOr)
cv2.waitKey(0)

Lors de l'exécution de l'opération OU bit à bit, vous devriez obtenir quelque chose comme ceci,

Exclusivité avec l'opération XOR

Une autre opération fournie par le module cv2 est l'opération XOR, que nous pouvons utiliser à travers la fonction bitwise_xor.

the bitwise_xor function executes the XOR operation
on both the images
bitwiseXor = cv2.bitwise_xor(rectangle, circle)
cv2.imshow("XOR", bitwiseXor)
cv2.waitKey(0)

Négation en utilisant l'opération NOT

Enfin, nous avons l'opération de négation, qui est effectuée à l'aide de la fonction bitwise_not.

L'opération NOT ne nécessite qu'une seule image car nous n'ajoutons ni ne soustrayons quoi que ce soit ici.

Nous l'utilisons toujours ici, cependant, c'est aussi une option.

the bitwise_not function executes the NOT operation
on both the images
bitwiseNot = cv2.bitwise_not(rectangle, circle)
cv2.imshow("NOT", bitwiseNot)
cv2.waitKey(0)

Le cercle est à l'intérieur du carré dans ce cas, et il n'est donc pas visible,

Masquage d'images à l'aide de Python OpenCV

Le masquage est utilisé en traitement d'image pour obtenir la région d'intérêt, ou simplement la partie de l'image qui nous intéresse.

Nous avons tendance à utiliser des opérations bit à bit pour le masquage car cela nous permet de rejeter les parties de l'image dont nous n'avons pas besoin.

Alors, commençons par le masquage !

Le processus de masquage des images

Nous avons trois étapes dans le masquage.

1. Créer un canvas noir avec les mêmes dimensions que l'image et l'appeler masque.
2. Changer les valeurs du masque en dessinant une figure quelconque dans l'image et en lui donnant une couleur blanche.
3. Effectuer l'opération d'ADD bit à bit sur l'image avec le masque.

En suivant le même processus, créons quelques masques et utilisons-les sur notre image.

Tout d'abord, travaillons avec un masque rectangulaire.

creating a mask of that has the same dimensions of the image
where each pixel is valued at 0
mask = np.zeros(image.shape[:2], dtype="uint8")

creating a rectangle on the mask
where the pixels are valued at 255
cv2.rectangle(mask, (0, 90), (290, 450), 255, -1)
cv2.imshow("Mask", mask)

performing a bitwise_and with the image and the mask
masked = cv2.bitwise_and(image, image, mask=mask)
cv2.imshow("Mask applied to Image", masked)
cv2.waitKey(0)

Maintenant, essayons avec un masque circulaire.

creating a mask of that has the same dimensions of the image
where each pixel is valued at 0
mask = np.zeros(image.shape[:2], dtype="uint8")

creating a rectangle on the mask
where the pixels are valued at 255
cv2.circle(mask, (145, 200), 100, 255, -1)
cv2.imshow("Mask", mask)

performing a bitwise_and with the image and the mask
masked = cv2.bitwise_and(image, image, mask=mask)
cv2.imshow("Mask applied to Image", masked)
cv2.waitKey(0)

Si tout se passe bien, nous devrions recevoir des résultats qui ressemblent à quelque chose comme ça,

Conclusion

Nous commençons enfin avec le cœur du traitement d'image, et comprendre les opérations bit à bit et le masquage est important.

Cela nous aide à bloquer certaines parties ou à ne prendre en compte que les parties de l'image qui nous intéressent, donc c'est un concept plutôt utile.

Nous avançons à un rythme décent, mais si vous souhaitez passer du temps et arriver à la fin, n'hésitez pas !

Voici des articles qui vous permettent d'explorer OpenCV et la reconnaissance faciale, ainsi qu'une implémentation Java d'Android et CameraX OpenCV.

Références

• Site officiel d'OpenCV
• Introduction à la prise en main d'OpenCV
• Mon référentiel GitHub pour le traitement d'image
• Code des opérations arithmétiques
• Code des opérations bit à bit
• Masquage de code