defzoek ArucoMarkers(afbeelding, markerSize=6, totaalMarkers=250):
# Converteer de afbeelding naar grijstinten
grijs = cv2.cvtColor (afbeelding, cv2.COLOR_BGR2GRAY)

# Download het Aruco-woordenboek op basis van de markeringsgrootte en het totale aantal markeringen
woordenboeksleutel = getattr (cv2.aruco, f'DICT_{markerSize}X'
F'{markerSize}_{totalMarkers}')

aruco_dictionary = cv2.aruco.getPredefinedDictionary (dictionary_key)

# Stel de parameters van de Aruco-detector in
aruco_params = cv2.aruco. DetectorParameters()

# Detecteer Aruco-markeringen in het grijswaardenbeeld
marker_corners, marker_ids, _ = cv2.aruco.detectMarkers (grijs, aruco_dictionary,
parameters=aruco_params)

defsuperimposeImageOnMarkers(video_frame, aruco_markers, overlay_image,
video_breedte, video_hoogte):
frame_height, frame_width = video_frame.shape[:2]

als len (aruco_markers[0]) != 0:
voor ik, marker_corner in opsommen (aruco_markers[0]):
marker_corners = marker_corner.hervormen((4, 2)).astype (np.int32)

# Teken een polygoon rond de markeringshoeken
cv2.polylines (video_frame, [marker_corners], WAAR, (0, 255, 0), 2)

instagram viewer

# Voeg markerings-ID toe als tekst in de linkerbovenhoek van de markering
cv2.putText (video_frame, str (aruco_markers[1][i]),
tuple (marker_corners[0]),
cv2.FONT_HERSHEY_SIMPLEX,0.5, (0, 255, 0), 2)

# Zoek de homografiematrix om de overlay-afbeelding op de markering te plaatsen
homography_matrix, _ = cv2.findHomography(
np.array([[0, 0], [videobreedte, 0], [videobreedte, videohoogte],
[0, video_height]], dtype="zweven32"), marker_corners)

# Verdraai de overlay-afbeelding om uit te lijnen met de markering met behulp van homografiematrix
warped_image = cv2.warpPerspective (overlay_image, homography_matrix,
(framebreedte, framehoogte))

# Maak een masker om de kromgetrokken afbeelding alleen op het markeringsgebied toe te passen
mask = np.zeros((frame_height, frame_width), dtype="uint8")
cv2.fillConvexPoly (masker, marker_corners, (255, 255, 255), cv2.LINE_AA)

masked_warped_image = cv2.bitwise_and (warped_image, warped_image,
masker=masker)

# Pas het omgekeerde masker toe op het videoframe
masked_video_frame = cv2.bitwise_and (video_frame, video_frame,
mask=cv2.bitwise_not (masker))

# Combineer het gemaskeerde kromgetrokken beeld en het gemaskeerde videoframe
video_frame = cv2.add (gemaskeerd_warped_image, gemaskeerd_video_frame)

defprocesVideoFeed(overlay_image):
# Stel de afmetingen van de videofeed in
video_hoogte = 480
videobreedte = 640

# Open de video-opname
video_capture = cv2.VideoCapture(0)

# Laad en verklein de overlay-afbeelding
overlay_image = cv2.resize (overlay_image, (video_width, video_height))

terwijl video_capture.isOpened():
# Lees een frame van de video-opname
ret, video_frame = video_capture.read()

als ret:
# Zoek Aruco-markeringen in het videoframe
aruco_markers = vindArucoMarkers (video_frame, totalMarkers=100)

# Plaats het overlay-beeld op de markeringen in het videoframe
video_frame = superimposeImageOnMarkers (video_frame, aruco_markers,
overlay_image, video_width,
video_hoogte)

# Geef het videoframe weer met overlay
cv2.imshow("Camerafeed", video_frame)

# Controleer of u op de 'q'-toets drukt om de lus te verlaten
als cv2.waitKey(1) & 0xFF == volgorde('Q'):
pauze