définitivementtrouverArucoMarkers(image, markerSize=6, totalMarkers=250):
# Convertir l'image en niveaux de gris
gris = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY)

# Obtenez le dictionnaire Aruco en fonction de la taille du marqueur et du nombre total de marqueurs
dictionnaire_clé = getattr (cv2.aruco, f'DICT_{markerSize}X'
F'{markerSize}_{totalMarkers}')

aruco_dictionary = cv2.aruco.getPredefinedDictionary (dictionary_key)

# Définir les paramètres du détecteur Aruco
aruco_params = cv2.aruco. Paramètres du détecteur()

# Détecter les marqueurs Aruco dans l'image en niveaux de gris
marker_corners, marker_ids, _ = cv2.aruco.detectMarkers (gris, aruco_dictionary,
paramètres=aruco_params)

définitivementsuperposerImageOnMarkers(video_frame, aruco_markers, overlay_image,
largeur_vidéo, hauteur_vidéo) :
frame_height, frame_width = video_frame.shape[ :2]

si len (aruco_markers[0]) != 0:
pour moi, marker_corner dans énumérer (aruco_markers[0]):
marker_corners = marker_corner.reshape((4, 2)).astype (np.int32)

instagram viewer

# Dessinez un polygone autour des coins du marqueur
cv2.polylines (video_frame, [marker_corners], Vrai, (0, 255, 0), 2)

# Ajouter l'ID du marqueur sous forme de texte dans le coin supérieur gauche du marqueur
cv2.putText (video_frame, str (aruco_markers[1][je]),
tuple (marker_corners[0]),
cv2.FONT_HERSHEY_SIMPLEX,0.5, (0, 255, 0), 2)

# Trouvez la matrice d'homographie pour mapper l'image de superposition sur le marqueur
homography_matrix, _ = cv2.findHomography(
np.tableau([[0, 0], [video_width, 0], [largeur_vidéo, hauteur_vidéo],
[0, hauteur_vidéo]], dtype="float32"), marker_corners)

# Déformez l'image de superposition pour l'aligner avec le marqueur à l'aide de la matrice d'homographie
warped_image = cv2.warpPerspective (overlay_image, homography_matrix,
(largeur_cadre, hauteur_cadre))

# Créez un masque pour appliquer l'image déformée uniquement sur la zone du marqueur
masque = 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,
masque = masque)

# Appliquez le masque inverse à l'image vidéo
masked_video_frame = cv2.bitwise_and (video_frame, video_frame,
masque=cv2.bitwise_not (masque))

# Combinez l'image déformée masquée et l'image vidéo masquée
video_frame = cv2.add (masked_warped_image, masked_video_frame)

définitivementprocessVideoFeed(superposition_image):
# Définir les dimensions du flux vidéo
hauteur_vidéo = 480
largeur_vidéo = 640

# Ouvrir la capture vidéo
video_capture = cv2.VideoCapture(0)

# Charger et redimensionner l'image de superposition
overlay_image = cv2.resize (overlay_image, (video_width, video_height))

alors que video_capture.isOpened() :
# Lire une image de la capture vidéo
ret, video_frame = video_capture.read()

si ret:
# Trouver des marqueurs Aruco dans l'image vidéo
aruco_markers = findArucoMarkers (video_frame, totalMarkers=100)

# Superposer l'image de superposition sur les marqueurs dans l'image vidéo
video_frame = superimposeImageOnMarkers (video_frame, aruco_markers,
overlay_image, video_width,
hauteur_vidéo)

# Afficher l'image vidéo avec superposition
cv2.imshow("Flux de caméra", image_vidéo)

# Vérifiez que la touche 'q' est enfoncée pour quitter la boucle
si cv2.waitKey(1) & 0xFF == ordre('q'):
casser