Cámaras

LeRobot ofrece varias opciones para la captura de video:

Para obtener detalles de compatibilidad de OpenCVCamera, consulte el Resumen de E/S de vídeo con OpenCV.

Encuentra tu cámara

Cada cámara requiere un identificador único para ser instanciada, lo que permite distinguir entre varios dispositivos conectados.

OpenCVCamera y RealSenseCamera admiten la detección automática. Ejecute el siguiente comando para listar los dispositivos disponibles y sus identificadores. Tenga en cuenta que estos identificadores pueden cambiar tras reiniciar su computadora o volver a conectar la cámara, dependiendo de su sistema operativo.

lerobot-find-cameras opencv # or realsense for Intel Realsense cameras

La salida se parecerá a esto si tienes dos cámaras conectadas:

--- Detected Cameras ---
Camera #0:
  Name: OpenCV Camera @ 0
  Type: OpenCV
  Id: 0
  Backend api: AVFOUNDATION
  Default stream profile:
    Format: 16.0
    Width: 1920
    Height: 1080
    Fps: 15.0
--------------------
(more cameras ...)

Al usar cámaras Intel RealSense en macOS, es posible que aparezca este error: Error finding RealSense cameras: failed to set power state. Esto se puede resolver ejecutando el mismo comando con permisos de sudo. Ten en cuenta que el uso de cámaras RealSense en macOS no es estable.

ZMQCamera y Reachy2Camera no admiten la detección automática. Deben configurarse manualmente proporcionando su dirección de red y puerto o la configuración del SDK del robot.

Colocación de la cámara e iluminación

Las imágenes de la cámara son de lo que aprende tu política, por lo que una buena configuración de la cámara es más importante que una alta resolución:

• Ilumina la escena de forma uniforme. Utiliza una luz difusa y constante, y evita la luz solar directa, los reflejos intensos y las sombras en movimiento. Una iluminación que difiera entre la grabación y la implementación puede hacer que la política falle.
• Fije las cámaras en su sitio. Montelas de forma rígida y no las mueva entre sesiones de grabación, ni entre la grabación y la implementación.
• Defina la tarea. El objeto, la pinza y el objetivo deben ser visibles en al menos una cámara. Una buena prueba: ¿podría realizar la tarea usted mismo mirando únicamente las imágenes de las cámaras?
• Mantén la resolución modesta. 640×480 a 30 fps es suficiente para la mayoría de las tareas y mantiene la grabación y el entrenamiento rápidos.

Usar cámaras

Modos de acceso a fotogramas

Todas las clases de cámara implementan tres modos de acceso para capturar fotogramas:

Ejemplos de uso

Los siguientes ejemplos muestran cómo usar la API de cámara para configurar y capturar fotogramas de diferentes tipos de cámara.

• Captura de fotogramas bloqueante y no bloqueante con una cámara basada en OpenCV
• Captura de color y profundidad con una cámara Intel RealSense

No desconectar las cámaras de forma limpia puede provocar fugas de recursos. Utilice el protocolo de gestor de contexto para garantizar la limpieza automática:

Copiado

with OpenCVCamera(config) as camera:
    ...

También puedes llamar a connect() y disconnect() manualmente, pero usa siempre un bloque finally para este último.

from lerobot.cameras.opencv import OpenCVCamera, OpenCVCameraConfig
from lerobot.cameras import ColorMode, Cv2Rotation

# Construct an `OpenCVCameraConfig` with your desired FPS, resolution, color mode, and rotation.
config = OpenCVCameraConfig(
    index_or_path=0,
    fps=15,
    width=1920,
    height=1080,
    color_mode=ColorMode.RGB,
    rotation=Cv2Rotation.NO_ROTATION
)

# Instantiate and connect an `OpenCVCamera`, performing a warm-up read (default).
with OpenCVCamera(config) as camera:

    # Read a frame synchronously — blocks until hardware delivers a new frame
    frame = camera.read()
    print(f"read() call returned frame with shape:", frame.shape)

    # Read a frame asynchronously with a timeout — returns the latest unconsumed frame or waits up to timeout_ms for a new one
    try:
        for i in range(10):
            frame = camera.async_read(timeout_ms=200)
            print(f"async_read call returned frame {i} with shape:", frame.shape)
    except TimeoutError as e:
        print(f"No frame received within timeout: {e}")

    # Instantly return a frame - returns the most recent frame captured by the camera
    try:
        initial_frame = camera.read_latest(max_age_ms=1000)
        for i in range(10):
            frame = camera.read_latest(max_age_ms=1000)
            print(f"read_latest call returned frame {i} with shape:", frame.shape)
            print(f"Was a new frame received by the camera? {not (initial_frame == frame).any()}")
    except TimeoutError as e:
        print(f"Frame too old: {e}")

from lerobot.cameras.realsense import RealSenseCamera, RealSenseCameraConfig
from lerobot.cameras import ColorMode, Cv2Rotation

# Create a `RealSenseCameraConfig` specifying your camera’s serial number and enabling depth.
config = RealSenseCameraConfig(
    serial_number_or_name="233522074606",
    fps=15,
    width=640,
    height=480,
    color_mode=ColorMode.RGB,
    use_depth=True,
    # Optional fixed color controls. Omit them to leave the current sensor settings unchanged.
    exposure=120,
    gain=64,
    white_balance=4600,
    rotation=Cv2Rotation.NO_ROTATION
)

# Instantiate and connect a `RealSenseCamera` with warm-up read (default).
camera = RealSenseCamera(config)
camera.connect()

# Capture a color frame via `read()` and a depth map via `read_depth()`.
try:
    color_frame = camera.read()
    depth_map = camera.read_depth()
    print("Color frame shape:", color_frame.shape)
    print("Depth map shape:", depth_map.shape)
finally:
    camera.disconnect()

Trabajar con profundidad

Las cámaras Intel RealSense y Reachy 2 pueden capturar color y profundidad de forma sincronizada. La llamada a read() devuelve el fotograma de color como (H, W, 3) uint8. La llamada a read_depth() devuelve el mapa de profundidad como (H, W, 1) uint16, donde cada valor de píxel es la distancia desde el sensor expresada en milímetros. Un valor de píxel de 0 suele significar “no hay medición disponible” (fuera de rango, ocluido o de baja confianza).

Durante la grabación, el bucle de control consulta de forma no bloqueante los fotogramas más recientes en el búfer mediante read_latest() (color) y read_latest_depth() (profundidad), añadiendo el mapa de profundidad como una característica hermana (p. ej. front_depth junto a front).

Para saber cómo se almacenan y codifican los flujos de profundidad al grabar un conjunto de datos, consulte la sección Flujos de profundidad de la guía de codificación de video.

Usa la cámara de tu teléfono

sudo apt install v4l2loopback-dkms v4l-utils

Si todo está configurado correctamente, tu teléfono aparecerá como una cámara estándar de OpenCV y podrá usarse con OpenCVCamera.