`csi` — capteurs de caméra¶

Le module csi est l’interface moderne et orientée objet vers le ou les capteurs de la caméra d’une OpenMV Cam. Chaque capteur physique est représenté par une instance de CSI, de sorte que les cartes d’imagerie multispectrale qui associent un capteur couleur à un capteur thermique ou événementiel peuvent piloter chacun d’eux indépendamment en passant un cid différent au constructeur. Les caméras à capteur unique se contentent d’instancier un seul CSI.

Un objet CSI détient l’intégralité de la configuration du capteur – format de pixel, taille de trame / fenêtre, exposition / gain / balance des blancs, miroir et retournement matériels, mire de barres de couleur, horloge de fréquence d’images, ROI pour l’exposition automatique, et commandes ioctl spécifiques à la puce. Les trames sont capturées avec CSI.snapshot(), qui renvoie une image.Image adossée au tampon d’image.

Ce module remplace l’ancien module sensor (qui exposait les mêmes fonctionnalités sous forme de fonctions au niveau du module liées à un unique capteur caché). Le nouveau code devrait utiliser CSI.

Exemple d’utilisation

import csi

# Setup camera.
csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.QVGA)
csi0.snapshot(time=2000)  # skip frames

# Take pictures.
while(True):
    csi0.snapshot()

Utilisation avec asyncio¶

La boucle CSI.snapshot() bloquante ci-dessus ne coopère pas avec la boucle d’événements asyncio – pendant que snapshot attend la trame suivante, toutes les autres coroutines du programme sont gelées. Pour permettre à une boucle de capture de coexister avec d’autres travaux concurrents (un client UART, une surveillance de bouton, une tâche réseau), enveloppez CSI dans un petit adaptateur qui transforme snapshot en une coroutine compatible avec await en interrogeant snapshot(blocking=False) et en rendant la main à la boucle d’événements entre les vérifications

import asyncio
import csi


class AsyncCSI:
    def __init__(self, *args, **kwargs):
        self._csi = csi.CSI(*args, **kwargs)

    def __getattr__(self, name):
        return getattr(self._csi, name)

    async def snapshot(self):
        while True:
            img = self._csi.snapshot(blocking=False)
            if img is not None:
                return img
            await asyncio.sleep_ms(0)

__getattr__ transmet tous les autres attributs (reset, pixformat, framesize, les réglages du capteur) au CSI sous-jacent, de sorte que le wrapper constitue un remplacement direct. Le premier appel non bloquant démarre également la capture DMA de la caméra si elle n’était pas déjà en cours, donc aucune amorce supplémentaire n’est nécessaire.

Une boucle de capture s’intègre alors dans un programme asyncio plus vaste comme une simple coroutine supplémentaire

async def capture_loop(cam):
    while True:
        img = await cam.snapshot()
        # process img here

async def main():
    cam = AsyncCSI()
    cam.reset()
    cam.pixformat(csi.RGB565)
    cam.framesize(csi.QVGA)

    asyncio.create_task(some_other_task())
    await capture_loop(cam)

asyncio.run(main())

Le réglage framebuffers reste important dans cette configuration – le mode à tampon unique fait que snapshot(blocking=False) renvoie None jusqu’à ce que la trame suivante soit capturée, tandis que le double ou triple tampon lisse cela de sorte que le wrapper trouve généralement une trame en tampon dès le premier sondage. Consultez la section finale AsyncCSI du tutoriel asyncio pour la démonstration complète.

classe CSI – Interface du capteur de caméra¶

La classe CSI est utilisée pour contrôler un capteur de caméra.

class csi.CSI(cid: int = -1, delays: bool = True, fflush: bool = True, stream: bool | None = None)¶

Crée un objet pour dialoguer avec un capteur de caméra. Sur les cartes équipées de plusieurs capteurs, l’objet CSI particulier peut être sélectionné en passant un cid tel que csi.LEPTON pour sélectionner un module de capteur FLIR Lepton. Si cid vaut -1, le capteur principal est sélectionné (généralement un module de caméra couleur sur les cartes multi-capteurs).

Si delays vaut False, tous les délais de stabilisation du pilote csi sont désactivés. Par défaut, le pilote du capteur temporise après une réinitialisation / un changement de mode afin d’éviter que des trames corrompues ne soient renvoyées par CSI.snapshot. Désactiver les délais vous permet de regrouper les mises à jour et d’appliquer un unique délai à la fin avant d’appeler CSI.snapshot.

Si fflush vaut False, le vidage automatique du tampon d’image mentionné dans CSI.framebuffers est désactivé. Cela supprime toute limite de temps sur les trames présentes dans la file FIFO du tampon d’image.

stream détermine si ce CSI est la source de flux envoyée à l’IDE. Si None (par défaut), le CSI devient la source de flux uniquement s’il s’agit du capteur principal (non auxiliaire). Passez True pour forcer ce CSI à être la source de flux, ou toute valeur fausse pour laisser inchangée la source de flux existante.

Méthodes¶

reset(hard: bool = True) → None¶: Initialise le capteur de caméra. Effectue une réinitialisation matérielle en basculant la broche GPIO du signal RESET vers le module de caméra si hard vaut True. hard doit être mis à faux lors de la réinitialisation de capteurs de caméra auxiliaires qui partagent la même broche GPIO du signal RESET que le module principal.

shutdown(enable: bool) → None¶: Place la caméra dans un mode de consommation plus faible que le sommeil (mais la caméra doit être réinitialisée à son réveil).

sleep(enable: bool) → None¶: Met la caméra en sommeil si enable vaut True. Sinon, la réveille.

flush() → None¶: Copie le contenu actuel du tampon d’image vers l’aperçu de l’IDE. Appelez ceci après le dernier CSI.snapshot si le script se termine, afin que l’IDE affiche la dernière trame.

snapshot(time: int = -1, frames: int = -1, blocking: bool = True, image: image.Image | None = None) → image.Image | None¶

Prend une photo à l’aide de la caméra et renvoie un objet image.Image.

Si time et/ou frames est passé, snapshot bloque pendant le nombre de millisecondes time indiqué et/ou jusqu’à ce que frames trames soient capturées depuis la caméra. Les deux arguments peuvent être utilisés en même temps. Une fois time et/ou frames écoulé, snapshot renvoie None.

blocking peut valoir False pour activer un comportement non bloquant qui fera que snapshot renvoie None lorsque l’image suivante de la caméra n’est pas prête, au lieu d’attendre.

image peut être un autre objet image.Image à mettre à jour avec la nouvelle image capturée depuis la caméra, au lieu de renvoyer un nouvel objet image.Image. Le contenu précédent de l’image est écrasé par une copie profonde.

Si CSI.auto_rotation est activé, cette méthode renvoie une image.Image déjà pivotée.

width() → int¶: Renvoie la largeur de résolution du capteur.

height() → int¶: Renvoie la hauteur de résolution du capteur.

cid() → int¶: Renvoie l’identifiant de puce du module de caméra. Comparez-le avec l’une des valeurs csi.OV2640, csi.OV5640, csi.OV7670, csi.OV7690, csi.OV7725, csi.OV9650, csi.MT9V022, csi.MT9V024, csi.MT9V032, csi.MT9V034, csi.MT9M114, csi.BOSON320, csi.BOSON640, csi.LEPTON, csi.HM01B0, csi.HM0360, csi.GC2145, csi.GENX320ES, csi.GENX320, csi.PAG7920, csi.PAG7936, csi.PAJ6100, csi.FROGEYE2020 ou csi.SOFTCSI.

readable() → bool¶: Renvoie True s’il y a une image prête à être renvoyée par CSI.snapshot, de sorte qu’un appel à snapshot ne bloquera pas.

pixformat(pixformat: int | None = None) → int | None¶

Définit le format de pixel du module de caméra à l’une des valeurs csi.GRAYSCALE, csi.RGB565, csi.BAYER, csi.YUV422 ou csi.JPEG (uniquement sur l’OV2640/OV5640).

Renvoie le pixformat actuel si appelée sans argument.

framesize(framesize: int | Tuple[int, int] | None = None) → int | None¶

Définit la taille de trame du module de caméra à l’une des constantes de taille (par ex. csi.QVGA, csi.VGA, csi.HD, etc. — voir la section des constantes).

Vous pouvez également passer une taille de trame personnalisée sous la forme d’un tuple (w, h). Lorsque CSI.snapshot est appelée, la taille de trame personnalisée sera évaluée par rapport aux règles DMA. En général, les tailles de trame doivent être un multiple de 8 pixels et/ou 16 octets.

Renvoie la taille de trame actuelle si appelée sans argument.

framerate(rate: int | None = None) → int | None¶

Définit la fréquence d’images en Hz pour le module de caméra.

Renvoie la fréquence d’images actuelle si appelée sans argument.

Note

CSI.framerate fonctionne en supprimant des trames reçues par le module de caméra afin de maintenir la fréquence d’images au niveau spécifié ou en dessous. Par défaut, la caméra fonctionnera à la fréquence d’images maximale. Si cela est implémenté pour le capteur de caméra particulier, CSI.framerate réduira également la fréquence d’images du capteur en interne pour économiser de l’énergie et améliorer la qualité d’image en augmentant l’exposition du capteur. CSI.framerate peut entrer en conflit avec CSI.auto_exposure sur certaines caméras.

window(roi: Tuple[int, int] | Tuple[int, int, int, int] | None = None) → Tuple[int, int, int, int] | None¶

Définit la résolution de la caméra sur une sous-région de la résolution actuelle. roi est un tuple (x, y, w, h). Vous pouvez aussi passer (w, h) et la fenêtre sera centrée.

Renvoie le tuple (x, y, w, h) actuel si appelée sans argument.

gainceiling(gainceiling: int) → bool¶

Définit le plafond de gain (gainceiling) de l’image de la caméra à l’une des valeurs 2, 4, 8, 16, 32, 64 ou 128.

Renvoie True en cas de succès et False en cas d’échec.

brightness(brightness: int) → bool¶

Définit la luminosité de l’image de la caméra.

Renvoie True en cas de succès et False en cas d’échec.

contrast(contrast: int) → bool¶

Définit le contraste de l’image de la caméra.

Renvoie True en cas de succès et False en cas d’échec.

saturation(saturation: int) → bool¶

Définit la saturation de l’image de la caméra.

Renvoie True en cas de succès et False en cas d’échec.

quality(quality: int) → bool¶

Définit la qualité de compression JPEG de l’image de la caméra. 0 - 100.

Renvoie True en cas de succès et False en cas d’échec.

Note

Uniquement pour les caméras OV2640/OV5640.

colorbar(enable: bool) → bool¶

Active (True) ou désactive (False) le mode mire de barres de couleur. Désactivé par défaut.

Renvoie True en cas de succès et False en cas d’échec.

auto_gain(enable: bool, gain_db: float | None = None, gain_db_ceiling: float | None = None) → None¶

enable active (True) ou désactive (False) le contrôle automatique de gain. La caméra démarre avec le contrôle automatique de gain activé.

Si enable vaut False, vous pouvez définir un gain fixe en décibels avec gain_db.

Si enable vaut True, vous pouvez définir le plafond de gain maximal en décibels avec gain_db_ceiling pour l’algorithme de contrôle automatique de gain.

Note

Vous devez également désactiver la balance des blancs si vous souhaitez suivre des couleurs.

gain_db() → float¶: Renvoie la valeur de gain actuelle de la caméra en décibels.

auto_exposure(enable: bool, exposure_us: int = -1) → None¶

enable active (True) ou désactive (False) le contrôle automatique d’exposition. La caméra démarre avec le contrôle automatique d’exposition activé.

Si enable vaut False, vous pouvez définir un temps d’exposition fixe en microsecondes avec exposure_us.

Note

Les algorithmes d’exposition automatique de la caméra sont assez conservateurs quant à l’ampleur de l’ajustement de la valeur d’exposition et éviteront généralement de la modifier beaucoup. À la place, ils modifient fortement la valeur de gain pour s’adapter aux variations de l’éclairage.

exposure_us() → int¶: Renvoie la valeur d’exposition actuelle de la caméra en microsecondes.

auto_whitebal(enable: bool, rgb_gain_db: Tuple[float, float, float] | None = None) → None¶

enable active (True) ou désactive (False) la balance des blancs automatique. La caméra démarre avec la balance des blancs automatique activée.

Si enable vaut False, vous pouvez définir un gain fixe en décibels pour les canaux rouge, vert et bleu respectivement avec rgb_gain_db.

Note

Vous devez également désactiver le contrôle de gain si vous souhaitez suivre des couleurs.

rgb_gain_db() → Tuple[float, float, float]¶: Renvoie un tuple (r, g, b) des valeurs de gain actuelles de la caméra pour le rouge, le vert et le bleu en décibels.

auto_blc(enable: bool, regs: List[int] | None = None) → None¶

Définit la calibration automatique du niveau de noir (BLC) sur la caméra.

enable passez True ou False pour activer ou désactiver le BLC. Vous voudrez généralement toujours l’activer.

regs si désactivé, vous pouvez définir manuellement les valeurs des registres BLC issues d’un appel précédent à CSI.blc_regs.

blc_regs() → List[int]¶: Renvoie les registres BLC du capteur sous forme de liste d’entiers. À utiliser avec CSI.auto_blc.

hmirror(enable: bool | None = None) → bool | None¶

Active (True) ou désactive (False) le mode miroir horizontal. Désactivé par défaut.

Renvoie le réglage actuel si appelée sans argument.

vflip(enable: bool | None = None) → bool | None¶

Active (True) ou désactive (False) le mode retournement vertical. Désactivé par défaut.

Renvoie le réglage actuel si appelée sans argument.

transpose(enable: bool | None = None) → bool | None¶

Active (True) ou désactive (False) le mode transposition. Désactivé par défaut.

vflip=False, hmirror=False, transpose=False -> rotation de 0 degré

vflip=True, hmirror=False, transpose=True -> rotation de 90 degrés

vflip=True, hmirror=True, transpose=False -> rotation de 180 degrés

vflip=False, hmirror=True, transpose=True -> rotation de 270 degrés

Renvoie le réglage actuel si appelée sans argument.

auto_rotation(enable: bool | None = None) → bool | None¶

Active (True) ou désactive (False) le mode rotation automatique. Désactivé par défaut.

Renvoie le réglage actuel si appelée sans argument.

Note

Cette méthode ne fonctionne que lorsque l’OpenMV Cam est équipée d’une imu et elle est activée automatiquement.

framebuffers(count: int | None = None) → int | None¶

Définit le nombre de tampons d’image utilisés pour recevoir les données d’image. Par défaut, l’OpenMV Cam tentera d’allouer le nombre maximal de tampons d’image possible. La réallocation se produit chaque fois que CSI.pixformat, CSI.framesize ou CSI.window sont appelées.

Un count de 1 (tampon unique), 2 (double tampon) ou 3 (triple tampon) sélectionne le mode de capture correspondant. Passez 4 ou plus pour placer le pilote en mode FIFO vidéo où count tampons sont mis en file — utile pour l’enregistrement vidéo sur une carte SD. En cas de perte de trame, tous les tampons d’image sauf celui actif sont vidés afin que CSI.snapshot renvoie toujours une trame récente.

Renvoie le nombre actuel si appelée sans argument.

special_effect(effect: int) → bool¶

Définit l’effet numérique spécial (l’une des valeurs csi.NORMAL ou csi.NEGATIVE).

Renvoie True en cas de succès et False en cas d’échec.

lens_correction(enable: bool, radi: int, coef: int) → bool¶

enable True pour activer, False pour désactiver. radi rayon entier de pixels à corriger. coef puissance de la correction.

Renvoie True en cas de succès et False en cas d’échec.

vsync_callback(cb: Callable[[int], None] | None = None) → Callable[[int], None] | None¶

Enregistre la fonction de rappel cb à exécuter (en contexte d’interruption) chaque fois que le module de caméra génère une nouvelle trame (mais avant que la trame ne soit reçue).

cb prend un argument et reçoit l’état actuel de la broche vsync après son changement.

Renvoie la fonction de rappel enregistrée si appelée sans argument. Passez tout objet non appelable pour effacer la fonction de rappel.

frame_callback(cb: Callable[[], None] | None = None) → Callable[[], None] | None¶

Enregistre la fonction de rappel cb à exécuter (en contexte d’interruption) chaque fois que le module de caméra génère une nouvelle trame et que celle-ci est prête à être lue via CSI.snapshot.

cb ne prend aucun argument. Utilisez ceci pour planifier la lecture d’une trame ultérieurement avec micropython.schedule().

Renvoie la fonction de rappel enregistrée si appelée sans argument. Passez tout objet non appelable pour effacer la fonction de rappel.

ioctl(request: int, *args) → Any¶

Exécute une requête spécifique au capteur. request est l’une des constantes IOCTL_* ; les autres arguments positionnels et la valeur de retour dépendent de la requête. Les requêtes prises en charge sont regroupées par famille de capteurs ci-dessous.

Générique (tout capteur) :

ioctl(IOCTL_SET_READOUT_WINDOW, (x, y, w, h))

ioctl(IOCTL_SET_READOUT_WINDOW, (w, h))

Définit la fenêtre de lecture du capteur. Une fenêtre plus petite augmente la fréquence d’images au détriment du champ de vision.

ioctl(IOCTL_GET_READOUT_WINDOW)

Renvoie la fenêtre de lecture actuelle sous forme de tuple (x, y, w, h).

ioctl(IOCTL_SET_TRIGGERED_MODE, enable)

Active (True) ou désactive (False) le mode déclenché sur le MT9V034.

ioctl(IOCTL_GET_TRIGGERED_MODE)

Renvoie l’état actuel du mode déclenché sous forme de bool.

ioctl(IOCTL_SET_FOV_WIDE, enable)

Lorsque True, demande à framesize() d’optimiser pour le champ de vision plutôt que pour la fréquence d’images.

ioctl(IOCTL_GET_FOV_WIDE)

Renvoie l’état actuel de FOV-wide sous forme de bool.

ioctl(IOCTL_SET_NIGHT_MODE, enable)

Active (True) ou désactive (False) le « mode nuit » faible luminosité du capteur. OV7725 et OV5640 uniquement.

ioctl(IOCTL_GET_NIGHT_MODE)

Renvoie l’état actuel du mode nuit sous forme de bool.

ioctl(IOCTL_GET_RGB_STATS)

Renvoie un 4-tuple de statistiques brutes des canaux RGB (r, gb, gr, b) lues depuis le capteur (généralement utilisé pour le réglage de la balance des blancs).

OV5640 FPC – mise au point automatique :

ioctl(IOCTL_TRIGGER_AUTO_FOCUS)

Lance un balayage de mise au point automatique sur le module OV5640 FPC.

ioctl(IOCTL_PAUSE_AUTO_FOCUS)

Met en pause un balayage de mise au point automatique en cours.

ioctl(IOCTL_RESET_AUTO_FOCUS)

Réinitialise la position de mise au point automatique à sa valeur par défaut.

ioctl(IOCTL_WAIT_ON_AUTO_FOCUS)

ioctl(IOCTL_WAIT_ON_AUTO_FOCUS, timeout_ms)

Bloque jusqu’à ce que le balayage de mise au point automatique en cours se termine. timeout_ms vaut 5000 par défaut si omis.

FLIR Lepton :

ioctl(IOCTL_LEPTON_GET_WIDTH)

Renvoie la largeur de l’image Lepton en pixels.

ioctl(IOCTL_LEPTON_GET_HEIGHT)

Renvoie la hauteur de l’image Lepton en pixels.

ioctl(IOCTL_LEPTON_GET_RADIOMETRY)

Renvoie le type du Lepton (radiométrique ou non) sous forme d’entier.

ioctl(IOCTL_LEPTON_GET_REFRESH)

Renvoie la fréquence de rafraîchissement du Lepton en Hz.

ioctl(IOCTL_LEPTON_GET_RESOLUTION)

Renvoie la résolution ADC du Lepton en bits.

ioctl(IOCTL_LEPTON_RUN_COMMAND, cmd)

Exécute une commande du SDK FLIR Lepton. cmd est l’identifiant de commande 16 bits défini par le SDK.

ioctl(IOCTL_LEPTON_SET_ATTRIBUTE, attr_id, payload)

Écrit un attribut du SDK Lepton. attr_id est l’identifiant d’attribut 16 bits ; payload est un bytes/bytearray dont la longueur doit être un multiple de 16 bits.

ioctl(IOCTL_LEPTON_GET_ATTRIBUTE, attr_id, words)

Lit un attribut du SDK Lepton. attr_id est l’identifiant d’attribut 16 bits ; words est le nombre de mots de 16 bits à lire. Renvoie un bytearray.

ioctl(IOCTL_LEPTON_GET_FPA_TEMP)

Renvoie la température du plan focal (focal-plane-array) du Lepton en degrés Celsius.

ioctl(IOCTL_LEPTON_GET_AUX_TEMP)

Renvoie la température auxiliaire du Lepton en degrés Celsius.

ioctl(IOCTL_LEPTON_SET_MODE, measurement_enabled)

ioctl(IOCTL_LEPTON_SET_MODE, measurement_enabled, high_temp_enabled)

Bascule le Lepton entre la sortie AGC et la sortie de température directe. measurement_enabled=True active la sortie de température directe. L’indicateur optionnel high_temp_enabled sélectionne la plage de hautes températures.

ioctl(IOCTL_LEPTON_GET_MODE)

Renvoie un 2-tuple (measurement_enabled, high_temp_enabled).

ioctl(IOCTL_LEPTON_SET_RANGE, (min_celsius, max_celsius))

Définit la plage de température mappée sur 0..255 lorsque le mode mesure est activé.

ioctl(IOCTL_LEPTON_GET_RANGE)

Renvoie la plage (min_celsius, max_celsius) actuelle.

Himax HM01B0 – détection de mouvement :

ioctl(IOCTL_HIMAX_MD_ENABLE, enable)

Active (True) ou désactive (False) le bloc de détection de mouvement intégré au capteur HM01B0.

ioctl(IOCTL_HIMAX_MD_WINDOW, (x, y, w, h))

ioctl(IOCTL_HIMAX_MD_WINDOW, (w, h))

Définit la fenêtre de détection de mouvement sur le HM01B0.

ioctl(IOCTL_HIMAX_MD_THRESHOLD, threshold)

Définit le seuil de détection de mouvement (0 – 255).

ioctl(IOCTL_HIMAX_MD_CLEAR)

Efface le verrou d’interruption de détection de mouvement.

ioctl(IOCTL_HIMAX_OSC_ENABLE, enable)

Active (True) ou désactive (False) l’oscillateur interne du HM01B0.

Prophesee GENX320 – capteur événementiel :

ioctl(IOCTL_GENX320_SET_BIASES, preset)

Applique un préréglage de polarisation. preset est l’une des constantes GENX320_BIASES_*.

ioctl(IOCTL_GENX320_SET_BIAS, bias, value)

Définit une polarisation unique. bias est l’une des constantes GENX320_BIAS_* ; value est le réglage entier.

ioctl(IOCTL_GENX320_SET_AFK, enable)

ioctl(IOCTL_GENX320_SET_AFK, enable, freq_low_hz, freq_high_hz)

Configure le filtre anti-scintillement. enable est un booléen ; les arguments de fréquence optionnels définissent la bande passante du filtre.

ioctl(IOCTL_GENX320_SET_STC, mode)

ioctl(IOCTL_GENX320_SET_STC, mode, arg1[, arg2])

Configure le filtre de contraste spatio-temporel. mode est l’une des constantes GENX320_STC_* ; jusqu’à deux autres arguments sont spécifiques au mode.

ioctl(IOCTL_GENX320_SET_MODE, mode)

ioctl(IOCTL_GENX320_SET_MODE, mode, evt_res)

Bascule le capteur entre les modes trame et événementiel. mode est l’une des constantes GENX320_MODE_*. Pour le mode événementiel, evt_res est la longueur de l’axe des lignes du tampon d’événements passé à IOCTL_GENX320_READ_EVENTS.

ioctl(IOCTL_GENX320_READ_EVENTS, buf)

Lit les événements dans buf, un ndarray uint16 de forme (EVT_res, 6) où EVT_res est une puissance de deux comprise entre 1024 et 65536. Les colonnes sont :

[0] – type d’événement (PIX_OFF_EVENT / PIX_ON_EVENT / déclencheur).

[1] – secondes.

[2] – millisecondes.

[3] – microsecondes.

[4] – coordonnée x.

[5] – coordonnée y.

Renvoie le nombre d’événements écrits.

ioctl(IOCTL_GENX320_READ_EVENTS_RAW)

Renvoie une image.Image contenant la trame d’événements brute du GENX320.

ioctl(IOCTL_GENX320_CALIBRATE, iterations, sigma)

Désactive les pixels dont le bruit dépasse sigma écarts-types par rapport à la distribution normale. iterations est le nombre entier de passes de calibration. Renvoie le nombre de pixels désactivés.

color_palette(palette: int | None = None) → int | None¶

Définit la palette de couleurs à utiliser pour des opérations telles que la conversion des niveaux de gris du FLIR Lepton en RGB565 ou la visualisation des événements du GENX320. L’une des valeurs image.PALETTE_RAINBOW, image.PALETTE_IRONBOW, et (lorsque pris en charge) image.PALETTE_DEPTH, image.PALETTE_EVT_DARK ou image.PALETTE_EVT_LIGHT.

Renvoie le réglage actuel si appelée sans argument.

__write_reg(address: int, value: int) → None¶: Écrit value dans le registre de la caméra à l’adresse address.

Note

Consultez la fiche technique de la caméra pour les informations sur les registres.

__read_reg(address: int) → int¶: Lit le registre de la caméra à l’adresse address.

Note

Consultez la fiche technique de la caméra pour les informations sur les registres.

Fonctions¶

csi.devices() → List[int]¶: Renvoie une liste des identifiants de puce des capteurs détectés.

Constantes¶

csi.BINARY: int¶: Format de pixel BINARY (bitmap). Chaque pixel fait 1 bit. Utile pour le stockage de masques ; peut être utilisé avec image.Image().

csi.GRAYSCALE: int¶: Format de pixel GRAYSCALE (Y de YUV422). Chaque pixel fait 8 bits.

csi.RGB565: int¶: Format de pixel RGB565. Chaque pixel fait 16 bits (5 bits de rouge, 6 bits de vert, 5 bits de bleu).

csi.BAYER: int¶: Format de pixel d’image RAW BAYER.

csi.YUV422: int¶: Format de pixel YUV422. Chaque pixel est stocké sous la forme d’une valeur Y de niveaux de gris 8 bits suivie de valeurs de couleur U/V 8 bits alternées partagées entre deux valeurs Y (Y1, U, Y2, V, …). Seules certaines méthodes de traitement d’image fonctionnent avec YUV422.

csi.JPEG: int¶: Mode JPEG. Le module de caméra produit des images JPEG compressées. Utilisez CSI.quality pour contrôler la qualité JPEG. Fonctionne uniquement pour les caméras OV2640/OV5640.

csi.OV2640: int¶: CSI.cid renvoie cette valeur pour la caméra OV2640.

csi.OV5640: int¶: CSI.cid renvoie cette valeur pour la caméra OV5640.

csi.OV7670: int¶: CSI.cid renvoie cette valeur pour la caméra OV7670.

csi.OV7690: int¶: CSI.cid renvoie cette valeur pour la caméra OV7690.

csi.OV7725: int¶: CSI.cid renvoie cette valeur pour la caméra OV7725.

csi.OV9650: int¶: CSI.cid renvoie cette valeur pour la caméra OV9650.

csi.MT9V022: int¶: CSI.cid renvoie cette valeur pour la caméra MT9V022.

csi.MT9V024: int¶: CSI.cid renvoie cette valeur pour la caméra MT9V024.

csi.MT9V032: int¶: CSI.cid renvoie cette valeur pour la caméra MT9V032.

csi.MT9V034: int¶: CSI.cid renvoie cette valeur pour la caméra MT9V034.

csi.MT9M114: int¶: CSI.cid renvoie cette valeur pour la caméra MT9M114.

csi.BOSON320: int¶: CSI.cid renvoie cette valeur pour la caméra BOSON 320x256.

csi.BOSON640: int¶: CSI.cid renvoie cette valeur pour la caméra BOSON 640x512.

csi.LEPTON: int¶: CSI.cid renvoie cette valeur pour les caméras LEPTON1/2/3.

csi.HM01B0: int¶: CSI.cid renvoie cette valeur pour la caméra HM01B0.

csi.HM0360: int¶: CSI.cid renvoie cette valeur pour la caméra HM0360.

csi.GC2145: int¶: CSI.cid renvoie cette valeur pour la caméra GC2145.

csi.GENX320ES: int¶: CSI.cid renvoie cette valeur pour la caméra GENX320 (échantillon d’ingénierie).

csi.GENX320: int¶: CSI.cid renvoie cette valeur pour la caméra GENX320.

csi.PAG7920: int¶: CSI.cid renvoie cette valeur pour la caméra PAG7920.

csi.PAG7936: int¶: CSI.cid renvoie cette valeur pour la caméra PAG7936.

csi.PAJ6100: int¶: CSI.cid renvoie cette valeur pour la caméra PAJ6100.

csi.FROGEYE2020: int¶: CSI.cid renvoie cette valeur pour la caméra FROGEYE2020.

csi.SOFTCSI: int¶: CSI.cid renvoie cette valeur pour la caméra CSI logicielle.

csi.NORMAL: int¶: Mode normal pour CSI.special_effect.

csi.NEGATIVE: int¶: Mode négatif pour CSI.special_effect.

csi.QCIF: int¶: Résolution 176x144 pour le capteur de caméra.

csi.CIF: int¶: Résolution 352x288 pour le capteur de caméra.

csi.QSIF: int¶: Résolution 176x120 pour le capteur de caméra.

csi.SIF: int¶: Résolution 352x240 pour le capteur de caméra.

csi.QQQVGA: int¶: Résolution 80x60 pour le capteur de caméra.

csi.QQVGA: int¶: Résolution 160x120 pour le capteur de caméra.

csi.QVGA: int¶: Résolution 320x240 pour le capteur de caméra.

csi.VGA: int¶: Résolution 640x480 pour le capteur de caméra.

csi.HQVGA: int¶: Résolution 240x160 pour le capteur de caméra.

csi.HVGA: int¶: Résolution 480x320 pour le capteur de caméra.

csi.WVGA: int¶: Résolution 720x480 pour le capteur de caméra MT9V034.

csi.WVGA2: int¶: Résolution 752x480 pour le capteur de caméra MT9V034.

csi.SVGA: int¶: Résolution 800x600 pour le capteur de caméra.

csi.XGA: int¶: Résolution 1024x768 pour le capteur de caméra.

csi.WXGA: int¶: Résolution 1280x768 pour le capteur de caméra MT9M114.

csi.SXGA: int¶: Résolution 1280x1024 pour le capteur de caméra. Fonctionne uniquement pour les caméras OV2640/OV5640.

csi.SXGAM: int¶: Résolution 1280x960 pour le capteur de caméra MT9M114.

csi.UXGA: int¶: Résolution 1600x1200 pour le capteur de caméra. Fonctionne uniquement pour les caméras OV2640/OV5640.

csi.HD: int¶: Résolution 1280x720 pour le capteur de caméra.

csi.FHD: int¶: Résolution 1920x1080 pour le capteur de caméra. Fonctionne uniquement pour la caméra OV5640.

csi.QHD: int¶: Résolution 2560x1440 pour le capteur de caméra. Fonctionne uniquement pour la caméra OV5640.

csi.QXGA: int¶: Résolution 2048x1536 pour le capteur de caméra. Fonctionne uniquement pour la caméra OV5640.

csi.WQXGA: int¶: Résolution 2560x1600 pour le capteur de caméra. Fonctionne uniquement pour la caméra OV5640.

csi.WQXGA2: int¶: Résolution 2592x1944 pour le capteur de caméra. Fonctionne uniquement pour la caméra OV5640.

csi.IOCTL_SET_READOUT_WINDOW: int¶: Définit la fenêtre de lecture. Voir CSI.ioctl.

csi.IOCTL_GET_READOUT_WINDOW: int¶: Récupère la fenêtre de lecture. Voir CSI.ioctl.

csi.IOCTL_SET_TRIGGERED_MODE: int¶: Définit le mode déclenché pour le MT9V034. Voir CSI.ioctl.

csi.IOCTL_GET_TRIGGERED_MODE: int¶: Récupère l’état du mode déclenché pour le MT9V034. Voir CSI.ioctl.

csi.IOCTL_SET_FOV_WIDE: int¶: Permet à CSI.framesize d’optimiser pour le champ de vision plutôt que pour les FPS. Voir CSI.ioctl.

csi.IOCTL_GET_FOV_WIDE: int¶: Renvoie si CSI.framesize optimise pour le champ de vision plutôt que pour les FPS. Voir CSI.ioctl.

csi.IOCTL_TRIGGER_AUTO_FOCUS: int¶: Déclenche la mise au point automatique sur le module de caméra OV5640 FPC. Voir CSI.ioctl.

csi.IOCTL_PAUSE_AUTO_FOCUS: int¶: Met en pause la mise au point automatique (en cours d’exécution) pour le module de caméra OV5640 FPC. Voir CSI.ioctl.

csi.IOCTL_RESET_AUTO_FOCUS: int¶: Réinitialise la mise au point automatique à sa valeur par défaut pour le module de caméra OV5640 FPC. Voir CSI.ioctl.

csi.IOCTL_WAIT_ON_AUTO_FOCUS: int¶: Attend la fin de la mise au point automatique sur le module de caméra OV5640 FPC. Voir CSI.ioctl.

csi.IOCTL_SET_NIGHT_MODE: int¶: Active ou désactive le mode nuit. Réduit la fréquence d’images pour augmenter dynamiquement l’exposition. Voir CSI.ioctl.

csi.IOCTL_GET_NIGHT_MODE: int¶: Renvoie si le mode nuit est activé. Voir CSI.ioctl.

csi.IOCTL_LEPTON_GET_WIDTH: int¶: Renvoie la largeur de résolution de l’image du FLIR Lepton en pixels. Voir CSI.ioctl.

csi.IOCTL_LEPTON_GET_HEIGHT: int¶: Renvoie la hauteur de résolution de l’image du FLIR Lepton en pixels. Voir CSI.ioctl.

csi.IOCTL_LEPTON_GET_RADIOMETRY: int¶: Renvoie le type du FLIR Lepton (radiométrique ou non). Voir CSI.ioctl.

csi.IOCTL_LEPTON_GET_REFRESH: int¶: Renvoie la fréquence de rafraîchissement du FLIR Lepton en Hz. Voir CSI.ioctl.

csi.IOCTL_LEPTON_GET_RESOLUTION: int¶: Renvoie la résolution ADC du FLIR Lepton en bits. Voir CSI.ioctl.

csi.IOCTL_LEPTON_RUN_COMMAND: int¶: Exécute une commande 16 bits du SDK FLIR Lepton. Voir CSI.ioctl.

csi.IOCTL_LEPTON_SET_ATTRIBUTE: int¶: Définit un attribut du FLIR Lepton issu du SDK FLIR Lepton. Voir CSI.ioctl.

csi.IOCTL_LEPTON_GET_ATTRIBUTE: int¶: Récupère un attribut du FLIR Lepton issu du SDK FLIR Lepton. Voir CSI.ioctl.

csi.IOCTL_LEPTON_GET_FPA_TEMP: int¶: Récupère la température du FPA du FLIR Lepton en Celsius. Voir CSI.ioctl.

csi.IOCTL_LEPTON_GET_AUX_TEMP: int¶: Récupère la température AUX du FLIR Lepton en Celsius. Voir CSI.ioctl.

csi.IOCTL_LEPTON_SET_MODE: int¶: Place le pilote du FLIR Lepton dans un mode où chaque pixel est une valeur de température. Voir CSI.ioctl.

csi.IOCTL_LEPTON_GET_MODE: int¶: Renvoie si le mode mesure est activé pour le capteur FLIR Lepton. Voir CSI.ioctl.

csi.IOCTL_LEPTON_SET_RANGE: int¶: Définit la plage de température mappée sur les valeurs de pixel en mode mesure. Voir CSI.ioctl.

csi.IOCTL_LEPTON_GET_RANGE: int¶: Renvoie la plage de température utilisée en mode mesure. Voir CSI.ioctl.

csi.IOCTL_HIMAX_MD_ENABLE: int¶: Contrôle l’interruption de détection de mouvement sur le HM01B0. Voir CSI.ioctl.

csi.IOCTL_HIMAX_MD_WINDOW: int¶: Définit la fenêtre de détection de mouvement sur le HM01B0. Voir CSI.ioctl.

csi.IOCTL_HIMAX_MD_THRESHOLD: int¶: Définit le seuil de détection de mouvement sur le HM01B0. Voir CSI.ioctl.

csi.IOCTL_HIMAX_MD_CLEAR: int¶: Efface l’interruption de détection de mouvement sur le HM01B0. Voir CSI.ioctl.

csi.IOCTL_HIMAX_OSC_ENABLE: int¶: Contrôle l’oscillateur interne sur le HM01B0. Voir CSI.ioctl.

csi.IOCTL_GET_RGB_STATS: int¶: Renvoie les statistiques RGB du capteur de caméra. Voir CSI.ioctl.

csi.IOCTL_GENX320_SET_BIASES: int¶: Définit les polarisations du capteur GENX320 sur l’un des préréglages GENX320_BIASES_*. Voir CSI.ioctl. Après CSI.reset, le pilote applique csi.GENX320_BIASES_LOW_NOISE, et non csi.GENX320_BIASES_DEFAULT — utilisez cet ioctl pour basculer vers un préréglage différent lorsque l’application nécessite plus de sensibilité ou de bande passante.

csi.GENX320_BIASES_DEFAULT: int¶: Valeurs par défaut de la fiche technique du GenX320 — équilibre entre sensibilité, bruit et bande passante pour les scènes générales.

csi.GENX320_BIASES_LOW_LIGHT: int¶: Réglé pour les conditions de faible luminosité — les deux seuils de contraste sont assouplis pour une sensibilité accrue, FO abaissé, HPF désactivé afin que les changements lents de luminosité soient toujours enregistrés.

csi.GENX320_BIASES_ACTIVE_MARKER: int¶: Réglé pour le suivi de LED clignotantes à fort contraste (marqueurs actifs) — les seuils de contraste sont relevés afin que seules les transitions nettes déclenchent, FO et HPF poussés au maximum pour maximiser la bande passante et rejeter la dérive ambiante lente, REFR=0 afin que chaque front de clignotement soit capturé.

csi.GENX320_BIASES_LOW_NOISE: int¶: Valeur par défaut du pilote — sensibilité plus faible que DEFAULT (seuils de contraste relevés) et un FO plus bas pour moins d’activité de bruit de fond. Idéal pour les scènes statiques ou lentes où les faux événements domineraient.

csi.GENX320_BIASES_HIGH_SPEED: int¶: Réglé pour les scènes à mouvement rapide — FO plus élevé pour une plus large bande passante des pixels, HPF plus élevé pour rejeter les changements lents, REFR plus élevé pour un temps mort plus long après chaque événement afin que la lecture ne sature pas.

csi.IOCTL_GENX320_SET_BIAS: int¶: Définit une polarisation unique du capteur GENX320 sur une valeur DAC. Passez une constante GENX320_BIAS_* (csi.GENX320_BIAS_DIFF_OFF, csi.GENX320_BIAS_DIFF_ON, csi.GENX320_BIAS_FO, csi.GENX320_BIAS_HPF ou csi.GENX320_BIAS_REFR) et une valeur DAC entière. Chaque polarisation est indépendante — appelez cet ioctl à plusieurs reprises pour ajuster uniquement les polarisations dont vous avez besoin après avoir appliqué un préréglage. Voir CSI.ioctl.

csi.GENX320_BIAS_DIFF_OFF: int¶: Seuil de contraste du comparateur négatif — contrôle de combien un pixel doit s’assombrir avant qu’un csi.PIX_OFF_EVENT ne se déclenche. Valeur plus basse = plus sensible (plus d’événements).

csi.GENX320_BIAS_DIFF_ON: int¶: Seuil de contraste du comparateur positif — contrôle de combien un pixel doit s’éclaircir avant qu’un csi.PIX_ON_EVENT ne se déclenche. Valeur plus basse = plus sensible (plus d’événements).

csi.GENX320_BIAS_FO: int¶: Fréquence de coupure passe-bas du pixel — arbitre entre la bande passante du pixel (vitesse/latence) et l’activité de bruit de fond. Valeur plus élevée = réponse du pixel plus rapide, plus de bruit.

csi.GENX320_BIAS_HPF: int¶: Fréquence de coupure passe-haut du pixel — rejette les changements lents de luminosité. Valeur plus élevée = changements plus lents filtrés (seules les transitions rapides sont enregistrées).

csi.GENX320_BIAS_REFR: int¶: Période réfractaire du pixel — temps mort après qu’un pixel a émis un événement, durant lequel il ne peut pas se déclencher à nouveau. Valeur plus élevée = temps mort plus long, moins d’événements provenant d’un pixel actif.

csi.IOCTL_GENX320_SET_AFK: int¶: Définit le filtre anti-scintillement (AFK) du GENX320, qui rejette les événements provenant de pixels qui basculent à une bande de fréquence périodique (éclairage fluorescent, écrans pilotés par LED, etc.). Passez enable (1 pour activer, 0 pour désactiver) et, lors de l’activation, les bords de bande en hertz : (enable, freq_low_hz, freq_high_hz). Voir CSI.ioctl.

csi.IOCTL_GENX320_SET_STC: int¶: Définit le mode du filtre de contraste spatio-temporel (STC) du GENX320. Passez une constante GENX320_STC_* (csi.GENX320_STC_DISABLE, csi.GENX320_STC_ONLY, csi.GENX320_STC_TRAIL_ONLY, csi.GENX320_STC_TRAIL) suivie du ou des seuils requis par le mode (en millisecondes). Voir CSI.ioctl.

csi.GENX320_STC_DISABLE: int¶: Désactive le filtre STC/trail du GENX320 — chaque événement passe.

csi.GENX320_STC_ONLY: int¶: Conserve le deuxième événement d’une rafale ; supprime le premier événement et tous les événements ultérieurs. Prend un paramètre, stc_threshold en millisecondes — les événements survenant dans cette fenêtre après un événement précédent sur le même pixel sont considérés comme faisant partie de la même rafale.

csi.GENX320_STC_TRAIL_ONLY: int¶: Conserve le premier événement d’une rafale ; supprime les événements suivants sur le même pixel jusqu’à ce que trail_threshold se soit écoulé. Prend un paramètre, trail_threshold en millisecondes.

csi.GENX320_STC_TRAIL: int¶: Conserve le premier événement d’une rafale plus les fronts suivants — combine csi.GENX320_STC_ONLY et csi.GENX320_STC_TRAIL_ONLY. Prend deux paramètres, stc_threshold et trail_threshold (tous deux en ms) ; le capteur requiert que les deux restent dans un rapport d’environ 13:1.

csi.IOCTL_GENX320_SET_MODE: int¶: Définit le mode de fonctionnement du GENX320. Passez csi.GENX320_MODE_HISTO pour l’histogramme d’événements intégré à la puce (la caméra se comporte comme une caméra à niveaux de gris classique à la fréquence d’images configurée) ou csi.GENX320_MODE_EVENT suivi de la longueur de l’axe des lignes de l”ndarray d’événements (une puissance de deux comprise entre 1024 et 65536) pour le flux d’événements brut. Voir CSI.ioctl.

csi.GENX320_MODE_HISTO: int¶: Mode histogramme — les événements sont accumulés sur la puce dans des cases par pixel et rapportés sous forme de trame en niveaux de gris 320x320 à la fréquence configurée (~20-350 FPS). La caméra se présente comme une caméra classique, de sorte que toutes les routines standard de traitement d’image fonctionnent directement.

csi.GENX320_MODE_EVENT: int¶: Mode événementiel — contourne l’histogramme intégré à la puce et diffuse les événements bruts dans un ndarray numpy avec des horodatages à la microseconde, pour les applications qui nécessitent un détail temporel complet plutôt qu’une trame pré-classée.

csi.IOCTL_GENX320_READ_EVENTS: int¶: Lit les événements bruts dans un ndarray uint16 de forme (EVT_res, 6) (avec EVT_res correspondant à la taille de tampon passée à csi.IOCTL_GENX320_SET_MODE). Les colonnes sont [0] type d’événement (csi.PIX_OFF_EVENT, csi.PIX_ON_EVENT, csi.EXT_TRIGGER_RISING/FALLING, csi.RST_TRIGGER_RISING/FALLING), [1] horodatage en secondes, [2] millisecondes, [3] microsecondes, [4] coordonnée X (0-319), [5] coordonnée Y (0-319). Renvoie le nombre d’événements écrits dans le tampon, laissant intactes les lignes plus anciennes au-delà de ce nombre. Voir CSI.ioctl.

csi.IOCTL_GENX320_CALIBRATE: int¶: Désactive automatiquement les pixels chauds — les pixels qui se déclenchent de manière parasite même sur une scène statique. Le pilote construit un comptage de coups par pixel 320x320, calcule la moyenne et l’écart-type, et désactive tout pixel dont le comptage dépasse mean + sigma * stddev. Passez un budget de comptage d’événements (événements à comptabiliser avant le calcul des statistiques — plus élevé = estimation plus fiable, plus lente ; ~10000 est une bonne valeur par défaut) et un flottant sigma (plus bas = plus agressif, ~0,5 par défaut). Renvoie le nombre de pixels désactivés. Pointez d’abord la caméra vers une scène statique afin que les événements liés au mouvement ne soient pas comptabilisés contre des pixels qui sont en réalité corrects. Voir CSI.ioctl.

csi.IOCTL_GENX320_READ_EVENTS_RAW: int¶: Renvoie une image.Image de trame d’événements brute du GENX320, avec les événements encore dans l’encodage compact natif de la puce — utile si vous souhaitez transférer le flux brut vers un PC pour un décodage hors ligne plutôt que de le traiter sur la caméra. Voir CSI.ioctl.

csi.PIX_OFF_EVENT: int¶: Type d’événement GENX320 (colonne [0]) — un pixel a détecté une diminution de luminosité (le seuil de contraste négatif a été franchi). Les colonnes [4]/[5] portent les coordonnées X/Y du pixel.

csi.PIX_ON_EVENT: int¶: Type d’événement GENX320 (colonne [0]) — un pixel a détecté une augmentation de luminosité (le seuil de contraste positif a été franchi). Les colonnes [4]/[5] portent les coordonnées X/Y du pixel.

csi.RST_TRIGGER_RISING: int¶: Type d’événement GENX320 (colonne [0]) — déclencheur de réinitialisation de pixel, front montant. X/Y ne sont pas utilisés. Non généré par le micrologiciel pour le moment.

csi.RST_TRIGGER_FALLING: int¶: Type d’événement GENX320 (colonne [0]) — déclencheur de réinitialisation de pixel, front descendant. X/Y ne sont pas utilisés. Non généré par le micrologiciel pour le moment.

csi.EXT_TRIGGER_RISING: int¶: Type d’événement GENX320 (colonne [0]) — la broche de déclenchement externe du capteur a vu un front montant. L’entrée de déclenchement externe du GENX320 est câblée à la ligne de synchronisation de trame de la caméra, également routée vers P10 sur le processeur et le connecteur de broches. X/Y ne sont pas utilisés.

csi.EXT_TRIGGER_FALLING: int¶: Type d’événement GENX320 (colonne [0]) — la broche de déclenchement externe du capteur a vu un front descendant. L’entrée de déclenchement externe du GENX320 est câblée à la ligne de synchronisation de trame de la caméra, également routée vers P10 sur le processeur et le connecteur de broches. X/Y ne sont pas utilisés.

csi — capteurs de caméra¶

Utilisation avec asyncio¶

classe CSI – Interface du capteur de caméra¶

Méthodes¶

Fonctions¶

Constantes¶

`csi` — capteurs de caméra¶