La réalité augmentée (RA) fusionne la réalité et le contenu virtuel en superposant des informations numériques à un environnement réel. Ces dernières années, les progrès réalisés dans le domaine de la vision par ordinateur et du traitement d’images ont facilité le développement d’applications de réalité augmentée.
OpenCV est une bibliothèque de vision par ordinateur à code source ouvert très répandue. Elle fournit des outils et des algorithmes qui vous aideront à créer des expériences de réalité augmentée convaincantes. Pour créer le programme de RA, vous choisirez une image de projection, détecterez un objet physique, puis projetterez et restituerez le contenu de RA.
Configuration de l’environnement
Avant de commencer à coder, vous devez préparer votre environnement de développement. Commencez par créer un environnement virtuel, puis exécutez cette commande de terminal pour installer NumPy et OpenCV :
pip install opencv-contrib-python numpy
Vous utiliserez OpenCV pour les fonctionnalités de vision par ordinateur et NumPy pour calculer une matrice d’homographie plus loin dans le code.
Assurez-vous d’installer opencv-contrib-python bibliothèque et non opencv-python. Ceci est dû au fait que opencv-python n’a pas l’option cv2.aruco sur lequel vous vous appuierez pour créer le programme de réalité augmentée.
Le code source complet est disponible dans un dépôt GitHub.
Importer les bibliothèques nécessaires
Créez un nouveau fichier Python. Au début du script, importez OpenCV et NumPy :
import numpy as np
import cv2
L’importation de ces bibliothèques vous permettra d’utiliser leurs fonctions dans votre code.
Choix de l’image de superposition
Lors du rendu d’objets virtuels dans la scène de réalité augmentée, vous avez besoin d’une image que l’application projettera sur les marqueurs détectés. Chargez l’image d’incrustation à l’aide de la fonction cv2.imread fonction.
overlay_image = cv2.imread('your_overlay_image.jpg')
Vous pouvez utiliser d’autres méthodes pour obtenir une image de superposition, comme la génération dynamique d’un modèle 3D.
Détection des marqueurs ArUco
Après avoir choisi l’image à superposer, vous devez déterminer la position de l’image dans votre flux vidéo. C’est là que les marqueurs ArUco entrent en jeu. Il s’agit de marqueurs carrés dotés d’un motif d’identification unique qui peut être facilement détecté par des algorithmes de vision artificielle.
Lorsqu’une application détecte un marqueur, elle peut réagir en projetant, par exemple, une image à sa place. Voici un exemple de marqueur ArUco.
Créez une fonction qui détectera les marqueurs ArUco dans votre flux vidéo. La fonction doit convertir le flux vidéo en niveaux de gris. Elle obtient ensuite le dictionnaire ArUco en fonction de la taille du marqueur et du nombre total de marqueurs. Enfin, elle doit détecter les marqueurs dans le flux.
def findArucoMarkers(image, markerSize=6, totalMarkers=250):
# Convert the image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Get the Aruco dictionary based on the marker size and total markers
dictionary_key = getattr(cv2.aruco, f'DICT_{markerSize}X'
f'{markerSize}_{totalMarkers}')
aruco_dictionary = cv2.aruco.getPredefinedDictionary(dictionary_key)
# Set the Aruco detector parameters
aruco_params = cv2.aruco.DetectorParameters()
# Detect Aruco markers in the grayscale image
marker_corners, marker_ids, _ = cv2.aruco.detectMarkers(gray, aruco_dictionary,
parameters=aruco_params)
return marker_corners, marker_ids
La fonction renvoie les coins et les ID des marqueurs détectés.
Projection de l’image de superposition sur les marqueurs
Une fois que vous avez détecté les marqueurs dans l’image vidéo, vous devez projeter l’image d’incrustation sur ces marqueurs. Pour ce faire, écrivez une fonction qui calcule la matrice d’homographie entre l’image et la trame vidéo. Il s’agit d’établir une transformation géométrique qui aligne l’image de superposition sur le marqueur ArUco détecté dans l’image vidéo.
Vous devez ensuite déformer l’image de superposition sur la base de l’homographie. Créez ensuite un masque pour définir la région de l’incrustation, puis fusionnez l’image d’incrustation masquée avec l’image vidéo.
def superimposeImageOnMarkers(video_frame, aruco_markers, overlay_image,
video_width, video_height):
frame_height, frame_width = video_frame.shape[:2]
if len(aruco_markers[0]) != 0:
for i, marker_corner in enumerate(aruco_markers[0]):
marker_corners = marker_corner.reshape((4, 2)).astype(np.int32)
# Draw a polygon around the marker corners
cv2.polylines(video_frame, [marker_corners], True, (0, 255, 0), 2)
# Add marker ID as text on the top-left corner of the marker
cv2.putText(video_frame, str(aruco_markers[1][i]),
tuple(marker_corners[0]),
cv2.FONT_HERSHEY_SIMPLEX,0.5, (0, 255, 0), 2)
# Find the homography matrix to map the overlay image onto the marker
homography_matrix, _ = cv2.findHomography(
np.array([[0, 0], [video_width, 0], [video_width, video_height],
[0, video_height]], dtype="float32"), marker_corners)
# Warp the overlay image to align with the marker using homography matrix
warped_image = cv2.warpPerspective(overlay_image, homography_matrix,
(frame_width, frame_height))
# Create a mask to apply the warped image only on the marker area
mask = np.zeros((frame_height, frame_width), dtype="uint8")
cv2.fillConvexPoly(mask, marker_corners, (255, 255, 255), cv2.LINE_AA)
masked_warped_image = cv2.bitwise_and(warped_image, warped_image,
mask=mask)
# Apply the inverse mask to the video frame
masked_video_frame = cv2.bitwise_and(video_frame, video_frame,
mask=cv2.bitwise_not(mask))
# Combine the masked warped image and masked video frame
video_frame = cv2.add(masked_warped_image, masked_video_frame)
return video_frame
La fonction renvoie l’image vidéo avec l’image de recouvrement superposée aux marqueurs ArUco détectés.
Rendu du contenu AR
Pour rendre le contenu AR, créez une fonction qui combine les étapes de détection des marqueurs et de projection de l’image. Cette fonction doit capturer en continu des images vidéo et détecter les marqueurs ArUco. Elle doit ensuite superposer l’image sur les marqueurs.
def processVideoFeed(overlay_image):
# Set the dimensions of the video feed
video_height = 480
video_width = 640
# Open the video capture
video_capture = cv2.VideoCapture(0)
# Load and resize the overlay image
overlay_image = cv2.resize(overlay_image, (video_width, video_height))
while video_capture.isOpened():
# Read a frame from the video capture
ret, video_frame = video_capture.read()
if ret:
# Find Aruco markers in the video frame
aruco_markers = findArucoMarkers(video_frame, totalMarkers=100)
# Superimpose the overlay image on the markers in the video frame
video_frame = superimposeImageOnMarkers(video_frame, aruco_markers,
overlay_image, video_width,
video_height)
# Display the video frame with overlay
cv2.imshow("Camera Feed", video_frame)
# Check for 'q' key press to exit the loop
if cv2.waitKey(1) & 0xFF == ord('q'):
break
video_capture.release()
cv2.destroyAllWindows()
La fonction affiche l’image vidéo résultante, créant ainsi l’illusion d’objets virtuels apparaissant dans le monde réel.
Pour exécuter le programme, exécutez la commande processVideoFeed fonction.
# Start processing the video feed
processVideoFeed(overlay_image)
Vous pouvez voir un exemple de sortie du programme dans cette vidéo :
Le marqueur dans votre flux vidéo doit avoir la même taille et les mêmes propriétés que celles que vous avez spécifiées dans le code.
Où s’applique la réalité augmentée ?
Divers secteurs et domaines utilisent la réalité augmentée pour améliorer l’expérience des clients. Les applications de réalité augmentée utilisées dans ces secteurs permettent aux clients de visualiser l’aspect des produits dans le monde réel.
Familiarisez-vous avec ce type d’application pour voir la technologie en action.
