100_fps_ir_led_tracking.py
# Ce travail est publié sous licence MIT.
# Copyright (c) 2013-2023 OpenMV LLC. Tous droits réservés.
# https://github.com/openmv/openmv/blob/master/LICENSE
#
# Cet exemple montre comment utiliser le contrôle de la fenêtre de lecture pour lire une petite partie
# de la matrice de pixels du capteur à très grande vitesse et déplacer cette fenêtre de lecture.
# Cet exemple a été conçu et testé sur l'OpenMV Cam H7 Plus avec le capteur OV5640.
import csi
import time
EXPOSURE_MICROSECONDS = 1000
TRACKING_THRESHOLDS = [(128, 255)] # Lorsque vous réduisez l'exposition, vous assombrissez toute l'image.
SEARCHING_RESOLUTION = csi.VGA
SEARCHING_AREA_THRESHOLD = 16
SEARCHING_PIXEL_THRESHOLD = SEARCHING_AREA_THRESHOLD
TRACKING_RESOLUTION = csi.QQVGA
TRACKING_AREA_THRESHOLD = 256
TRACKING_PIXEL_THRESHOLD = TRACKING_AREA_THRESHOLD
TRACKING_EDGE_TOLERANCE = 0.05 # Le blob peut s'éloigner de 5 % par rapport au centre.
csi0 = csi.CSI()
csi0.reset() # Réinitialiser et initialiser le capteur.
csi0.pixformat(csi.GRAYSCALE) # Définir le format de pixel sur GRAYSCALE
csi0.framesize(SEARCHING_RESOLUTION)
csi0.snapshot(time=1000) # Attendre que les réglages prennent effet.
clock = time.clock() # Créer un objet horloge pour suivre le FPS.
csi0.auto_gain(False) # Désactiver, car cela va osciller.
csi0.auto_exposure(False, exposure_us=EXPOSURE_MICROSECONDS)
csi0.snapshot(time=1000)
# sensor_w et sensor_h correspondent à la largeur/hauteur en pixels bruts du capteur d'image (x/y valent 0 initialement).
x, y, sensor_w, sensor_h = csi0.ioctl(csi.IOCTL_GET_READOUT_WINDOW)
while True:
clock.tick()
img = csi0.snapshot()
# Il faut trouver un objet IR à suivre - il est probablement très lumineux.
blobs = img.find_blobs(
TRACKING_THRESHOLDS,
area_threshold=SEARCHING_AREA_THRESHOLD,
pixels_threshold=SEARCHING_PIXEL_THRESHOLD,
)
if len(blobs):
most_dense_blob = max(blobs, key=lambda x: x.density)
img.draw_rectangle(most_dense_blob.rect)
def get_mapped_centroid(b):
# Par défaut, la fenêtre de lecture est définie sur l'ensemble de la matrice de pixels du capteur, avec x/y==0.
# La résolution que vous voyez est produite en prélevant des pixels dans la fenêtre de lecture sur
# la caméra. La position x/y est relative au centre du capteur.
x, y, w, h = csi0.ioctl(csi.IOCTL_GET_READOUT_WINDOW)
# Le pilote de la caméra essaiera de mettre à l'échelle pour s'adapter à la résolution que vous transmettez, jusqu'à la
# largeur/hauteur maximale qui tient sur le capteur, tout en conservant le rapport d'aspect.
ratio = min(w / float(csi0.width()), h / float(csi0.height()))
# Référencer cx() par rapport au centre de la fenêtre d'affichage, puis mettre à l'échelle vers la fenêtre de lecture.
mapped_cx = (b.cx - (csi0.width() / 2.0)) * ratio
# Comme le rapport d'aspect est conservé, il peut y avoir un décalage en x.
mapped_cx += (w - (csi0.width() * ratio)) / 2.0
# Ajouter notre déplacement par rapport au centre du capteur
mapped_cx += x + (sensor_w / 2.0)
# Référencer cy() par rapport au centre de la fenêtre d'affichage, puis mettre à l'échelle vers la fenêtre de lecture.
mapped_cy = (b.cy - (csi0.height() / 2.0)) * ratio
# Comme le rapport d'aspect est conservé, il peut y avoir un décalage en y.
mapped_cy += (h - (csi0.height() * ratio)) / 2.0
# Ajouter notre déplacement par rapport au centre du capteur
mapped_cy += y + (sensor_h / 2.0)
return (mapped_cx, mapped_cy) # Position X/Y sur la matrice du capteur.
def center_on_blob(b, res):
mapped_cx, mapped_cy = get_mapped_centroid(b)
# Basculer vers la résolution (si la résolution n'a pas changé, cela ne fait rien).
csi0.framesize(res)
# Construire la fenêtre de lecture. x/y sont des décalages par rapport au centre.
x = int(mapped_cx - (sensor_w / 2.0))
y = int(mapped_cy - (sensor_h / 2.0))
w = csi0.width()
h = csi0.height()
# Se concentrer sur le centroïde.
csi0.ioctl(csi.IOCTL_SET_READOUT_WINDOW, (x, y, w, h))
# Vérifier si l'on atteint le bord.
new_x, new_y, w, h = csi0.ioctl(csi.IOCTL_GET_READOUT_WINDOW)
# Vous pouvez utiliser ces valeurs d'erreur pour piloter des servomoteurs afin de déplacer la caméra si vous le souhaitez.
x_error = x - new_x
y_error = y - new_y
if x_error < 0:
print("-X Limit Reached ", end="")
if x_error > 0:
print("+X Limit Reached ", end="")
if y_error < 0:
print("-Y Limit Reached ", end="")
if y_error > 0:
print("+Y Limit Reached ", end="")
center_on_blob(most_dense_blob, TRACKING_RESOLUTION)
# Cette boucle suivra le blob à une vitesse de lecture bien plus élevée et à une résolution plus faible.
while True:
clock.tick()
img = csi0.snapshot()
# Trouver le blob dans l'image en résolution plus faible.
blobs = img.find_blobs(
TRACKING_THRESHOLDS,
area_threshold=TRACKING_AREA_THRESHOLD,
pixels_threshold=TRACKING_PIXEL_THRESHOLD,
)
# Si l'on perd le blob, il faut en trouver un nouveau.
if not len(blobs):
# Réinitialiser la résolution.
csi0.framesize(SEARCHING_RESOLUTION)
csi0.ioctl(csi.IOCTL_SET_READOUT_WINDOW, (sensor_w, sensor_h))
break
# Réduire la liste des blobs et mettre en surbrillance le blob.
most_dense_blob = max(blobs, key=lambda x: x.density)
img.draw_rectangle(most_dense_blob.rect)
print(
clock.fps(), "BLOB cx:%d, cy:%d" % get_mapped_centroid(most_dense_blob)
)
x_diff = most_dense_blob.cx - (csi0.width() / 2.0)
y_diff = most_dense_blob.cy - (csi0.height() / 2.0)
w_threshold = (csi0.width() / 2.0) * TRACKING_EDGE_TOLERANCE
h_threshold = (csi0.height() / 2.0) * TRACKING_EDGE_TOLERANCE
# Recentrer sur le blob s'il commence à sortir du champ de vue (coûte du FPS).
if abs(x_diff) > w_threshold or abs(y_diff) > h_threshold:
center_on_blob(most_dense_blob, TRACKING_RESOLUTION)
print(clock.fps())