""" Implémentation de la capture vidéo pour Raspberry Pi via PiCamera2. Dépendance : picamera2 (sudo apt install python3-picamera2) Compatible Pi 4 / Pi 5 avec le module caméra officiel. """ import io import logging from typing import Optional from .capture_interface import CaptureError, VideoCaptureInterface logger = logging.getLogger(__name__) class PiCamera2Capture(VideoCaptureInterface): """ Capture JPEG depuis la caméra officielle Raspberry Pi via PiCamera2. Utilise le pipeline libcamera pour la capture basse latence. Supporte les modules Camera Module v1, v2, v3 et HQ Camera. Exemple d'utilisation :: cam = PiCamera2Capture(fps=5, width=1280, height=720) cam.set_frame_callback(lambda data, ts: print(f"{ts}: {len(data)} octets")) cam.start() time.sleep(10) cam.stop() """ def __init__( self, fps: float = VideoCaptureInterface.DEFAULT_FPS, width: int = 1280, height: int = 720, jpeg_quality: int = 85, camera_index: int = 0, use_video_config: bool = True, ): """ :param fps: Cadence cible en images par seconde :param width: Largeur du flux de capture en pixels :param height: Hauteur du flux de capture en pixels :param jpeg_quality: Qualité de compression JPEG [0-100] :param camera_index: Index de la caméra (0 par défaut, utile sur Pi 5 dual-cam) :param use_video_config: True = configuration VideoConfiguration (flux continu) False = StillConfiguration (haute résolution, plus lent) """ super().__init__(fps=fps) self._width: int = width self._height: int = height self._jpeg_quality: int = jpeg_quality self._camera_index: int = camera_index self._use_video_config: bool = use_video_config self._picam2 = None # Instance Picamera2 # ------------------------------------------------------------------ # Implémentation des méthodes abstraites # ------------------------------------------------------------------ def open(self) -> None: """ Initialise PiCamera2, configure le flux et démarre le pipeline libcamera. """ try: from picamera2 import Picamera2 # Import local : disponible uniquement sur Pi except ImportError as exc: raise CaptureError( "picamera2 introuvable — installez-le avec : " "sudo apt install python3-picamera2" ) from exc try: self._picam2 = Picamera2(self._camera_index) # Choix de la configuration selon le mode sélectionné if self._use_video_config: config = self._picam2.create_video_configuration( main={"size": (self._width, self._height), "format": "RGB888"}, ) logger.debug("Configuration VideoConfiguration sélectionnée") else: config = self._picam2.create_still_configuration( main={"size": (self._width, self._height), "format": "RGB888"}, ) logger.debug("Configuration StillConfiguration sélectionnée") self._picam2.configure(config) self._picam2.start() logger.info( "PiCamera2 ouverte : index=%d résolution=%dx%d mode=%s", self._camera_index, self._width, self._height, "video" if self._use_video_config else "still", ) except Exception as exc: # Nettoyage en cas d'échec partiel d'initialisation if self._picam2 is not None: try: self._picam2.close() except Exception: # noqa: BLE001 pass self._picam2 = None raise CaptureError(f"Impossible d'ouvrir PiCamera2 : {exc}") from exc def close(self) -> None: """Arrête le pipeline libcamera et libère les ressources.""" if self._picam2 is not None: try: self._picam2.stop() self._picam2.close() logger.info("PiCamera2 fermée (index=%d)", self._camera_index) except Exception as exc: # noqa: BLE001 logger.warning("Erreur lors de la fermeture de PiCamera2 : %s", exc) finally: self._picam2 = None def capture_frame(self) -> bytes: """ Capture une image depuis le flux libcamera et l'encode en JPEG. Stratégie : capture_array() → tableau NumPy RGB → encodage Pillow. capture_file() ne supporte pas le paramètre quality ; on encode manuellement pour contrôler le taux de compression. :return: Données JPEG brutes :raises CaptureError: Si la capture ou l'encodage échoue """ if self._picam2 is None: raise CaptureError("PiCamera2 n'est pas initialisée") try: from PIL import Image # Récupération du tableau RGB depuis le flux libcamera arr = self._picam2.capture_array("main") # shape (H, W, 3) uint8 # Encodage manuel en JPEG avec la qualité configurée buf = io.BytesIO() Image.fromarray(arr).save(buf, format="JPEG", quality=self._jpeg_quality) return buf.getvalue() except Exception as exc: raise CaptureError(f"Échec de capture PiCamera2 : {exc}") from exc def is_available(self) -> bool: """Retourne True si le pipeline libcamera est démarré.""" return self._picam2 is not None # ------------------------------------------------------------------ # Méthodes spécifiques à PiCamera2 # ------------------------------------------------------------------ def capture_high_res(self, width: int, height: int) -> bytes: """ Capture une image haute résolution hors flux principal (photo ponctuelle). Utile pour déclencher une capture pleine résolution pendant un flux 5 fps. Utilise capture_request() + make_array() + encodage Pillow. :param width: Largeur souhaitée en pixels (indicatif, dépend de la config active) :param height: Hauteur souhaitée en pixels :return: Données JPEG brutes :raises CaptureError: Si PiCamera2 n'est pas initialisée """ if self._picam2 is None: raise CaptureError("PiCamera2 n'est pas initialisée") try: from PIL import Image # Capture d'une requête unique depuis le flux actif request = self._picam2.capture_request() arr = request.make_array("main") # shape (H, W, 3) uint8 RGB request.release() buf = io.BytesIO() Image.fromarray(arr).save(buf, format="JPEG", quality=self._jpeg_quality) return buf.getvalue() except Exception as exc: raise CaptureError(f"Échec de capture haute résolution : {exc}") from exc def set_controls(self, **kwargs) -> None: """ Applique des contrôles libcamera directement (exposition, gain, balance des blancs…). Exemple :: cam.set_controls(ExposureTime=10000, AnalogueGain=2.0) :param kwargs: Contrôles libcamera valides pour le module connecté """ if self._picam2 is None: raise CaptureError("PiCamera2 n'est pas initialisée") self._picam2.set_controls(kwargs) logger.debug("Contrôles appliqués : %s", kwargs) def get_camera_properties(self) -> dict: """ Retourne les métadonnées du module caméra détecté. :return: Dictionnaire des propriétés (modèle, résolution max, etc.) """ if self._picam2 is None: raise CaptureError("PiCamera2 n'est pas initialisée") return self._picam2.camera_properties @property def jpeg_quality(self) -> int: """Qualité JPEG [0-100].""" return self._jpeg_quality @jpeg_quality.setter def jpeg_quality(self, value: int) -> None: if not 0 <= value <= 100: raise ValueError("La qualité JPEG doit être comprise entre 0 et 100") self._jpeg_quality = value @property def resolution(self) -> tuple[int, int]: """Résolution de capture configurée (largeur, hauteur).""" return (self._width, self._height)