rcs-zed 0.7.3__py3-none-any.whl

rcs_zed/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.6.3"

rcs_zed/__main__.py

@@ -0,0 +1,194 @@
+import logging
+from pathlib import Path
+from time import monotonic
+
+import cv2
+import typer
+from rcs_zed.camera import ZEDCameraSet
+
+from rcs import common
+
+logger = logging.getLogger(__name__)
+zed_app = typer.Typer(help="CLI tools for the ZED camera module of rcs.")
+
+
+def _display_frame(window_name: str, frame):
+    cv2.imshow(window_name, frame.camera.color.data[:, :, ::-1])
+
+
+def _resolve_serial(serial: str | None) -> str:
+    if serial is not None:
+        return serial
+
+    try:
+        devices = ZEDCameraSet.enumerate_connected_devices()
+    except RuntimeError as exc:
+        msg = str(exc)
+        raise typer.BadParameter(msg) from exc
+    if len(devices) == 0:
+        msg = "No ZED devices connected."
+        raise typer.BadParameter(msg)
+    return next(iter(devices))
+
+
+def _create_rgb_camera(serial: str, width: int, height: int, fps: int) -> ZEDCameraSet:
+    return ZEDCameraSet(
+        cameras={
+            "viewer": common.BaseCameraConfig(
+                identifier=serial,
+                resolution_width=width,
+                resolution_height=height,
+                frame_rate=fps,
+            )
+        },
+        enable_depth=False,
+        enable_imu=False,
+    )
+
+
+@zed_app.command()
+def serials():
+    """Reads out the serial numbers and models of connected ZED devices via the SDK."""
+    try:
+        devices = ZEDCameraSet.enumerate_connected_devices()
+    except RuntimeError as exc:
+        typer.secho(str(exc), fg=typer.colors.YELLOW, err=True)
+        return
+    if len(devices) == 0:
+        typer.secho("No ZED devices connected or the ZED SDK is not available.", fg=typer.colors.YELLOW, err=True)
+        return
+    typer.echo("Connected devices:")
+    for device in devices.values():
+        typer.echo(f"  {device.model}: {device.serial} (imu={device.has_imu})")
+
+
+def _format_intrinsics(name: str, matrix) -> str:
+    fx, fy, cx, cy = float(matrix[0, 0]), float(matrix[1, 1]), float(matrix[0, 2]), float(matrix[1, 2])
+    lines = [
+        f"{name}:",
+        f"  fx={fx:.6f} fy={fy:.6f} cx={cx:.6f} cy={cy:.6f}",
+        f"  K=\n{matrix}",
+    ]
+    return "\n".join(lines)
+
+
+@zed_app.command()
+def intrinsics(
+    serial: str | None = typer.Argument(None, help="Optional ZED serial number. Uses the first device if omitted."),
+    width: int = typer.Option(1280, help="Requested capture width."),
+    height: int = typer.Option(720, help="Requested capture height."),
+    fps: int = typer.Option(30, help="Requested capture frame rate."),
+    right: bool = typer.Option(False, "--right", help="Also print right-camera intrinsics."),
+):
+    """Open a ZED camera and print its RGB intrinsics for the requested resolution."""
+    serial = _resolve_serial(serial)
+    config = common.BaseCameraConfig(
+        identifier=serial,
+        resolution_width=width,
+        resolution_height=height,
+        frame_rate=fps,
+    )
+    try:
+        handle = ZEDCameraSet.open_camera(
+            config,
+            enable_depth=False,
+            enable_imu=False,
+            include_right=right,
+        )
+    except Exception as exc:
+        msg = f"Could not start ZED camera {serial}: {exc}"
+        raise typer.BadParameter(msg) from exc
+
+    try:
+        typer.echo(f"serial={handle.device_info.serial} model={handle.device_info.model} resolution={width}x{height}")
+        typer.echo(_format_intrinsics("left", handle.color_intrinsics))
+        if right and handle.right_color_intrinsics is not None:
+            typer.echo(_format_intrinsics("right", handle.right_color_intrinsics))
+    finally:
+        handle.close()
+
+
+@zed_app.command("rgb-view")
+def rgb_view(
+    serial: str | None = typer.Argument(None, help="Optional ZED serial number. Uses the first device if omitted."),
+    width: int = typer.Option(1280, help="Requested capture width."),
+    height: int = typer.Option(720, help="Requested capture height."),
+    fps: int = typer.Option(30, help="Requested capture frame rate."),
+    window_name: str = typer.Option("ZED RGB", help="OpenCV window title."),
+):
+    """Open a live RGB window using the RCS ZED camera interface."""
+    serial = _resolve_serial(serial)
+    camera = _create_rgb_camera(serial, width, height, fps)
+
+    try:
+        camera.open()
+    except Exception as exc:
+        msg = f"Could not start ZED camera {serial}: {exc}"
+        raise typer.BadParameter(msg) from exc
+
+    logger.info("Streaming RGB from ZED %s. Press 'q' to quit.", serial)
+    try:
+        while True:
+            frame = camera.poll_frame("viewer")
+            _display_frame(window_name, frame)
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                break
+    finally:
+        camera.close()
+        cv2.destroyAllWindows()
+
+
+@zed_app.command("rgb-snapshot")
+def rgb_snapshot(
+    serial: str | None = typer.Argument(None, help="Optional ZED serial number. Uses the first device if omitted."),
+    output: str = typer.Option("zed_latest.png", "--output", "-o", help="PNG file to write."),
+    width: int = typer.Option(1280, help="Requested capture width."),
+    height: int = typer.Option(720, help="Requested capture height."),
+    fps: int = typer.Option(30, help="Requested capture frame rate."),
+    duration: float = typer.Option(1.0, "--duration", "-d", help="Seconds to read frames before saving."),
+):
+    """Open a ZED camera briefly and save the latest RGB frame as a PNG."""
+    output_path = Path(output)
+    if duration <= 0:
+        msg = "Duration must be greater than zero."
+        raise typer.BadParameter(msg)
+    if output_path.suffix.lower() != ".png":
+        msg = "Output path must end in .png."
+        raise typer.BadParameter(msg)
+
+    serial = _resolve_serial(serial)
+    camera = _create_rgb_camera(serial, width, height, fps)
+
+    try:
+        camera.open()
+    except Exception as exc:
+        msg = f"Could not start ZED camera {serial}: {exc}"
+        raise typer.BadParameter(msg) from exc
+
+    latest_frame = None
+    frames_read = 0
+    deadline = monotonic() + duration
+    try:
+        while latest_frame is None or monotonic() < deadline:
+            latest_frame = camera.poll_frame("viewer")
+            frames_read += 1
+    finally:
+        camera.close()
+
+    assert latest_frame is not None
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    image_bgr = latest_frame.camera.color.data[:, :, ::-1]
+    print(latest_frame.camera.color.intrinsics)
+    if not cv2.imwrite(str(output_path), image_bgr):
+        msg = f"Could not write PNG to {output_path}."
+        raise typer.BadParameter(msg)
+
+    typer.echo(f"Saved {output} from ZED {serial} after reading {frames_read} frame(s).")
+
+
+def main():
+    zed_app()
+
+
+if __name__ == "__main__":
+    main()

rcs_zed/camera.py

@@ -0,0 +1,411 @@
+import copy
+import logging
+import threading
+import typing
+from dataclasses import dataclass
+from time import time
+
+import numpy as np
+from rcs.camera.hw import CalibrationStrategy, DummyCalibrationStrategy, HardwareCamera
+from rcs.camera.interface import BaseCameraSet, CameraFrame, DataFrame, Frame, IMUFrame
+
+from rcs import common
+
+try:
+    from pyzed import sl
+except ImportError:  # pragma: no cover - exercised via fake backend tests
+    sl = None  # type: ignore[assignment]
+
+
+@dataclass
+class ZEDDeviceInfo:
+    serial: str
+    model: str
+    has_depth: bool = True
+    has_imu: bool = False
+
+
+@dataclass
+class ZEDFrameBundle:
+    color: np.ndarray
+    timestamp: float
+    color_intrinsics: np.ndarray[tuple[typing.Literal[3], typing.Literal[4]], np.dtype[np.float64]]
+    right_color: np.ndarray | None = None
+    right_color_intrinsics: np.ndarray[tuple[typing.Literal[3], typing.Literal[4]], np.dtype[np.float64]] | None = None
+    depth: np.ndarray | None = None
+    accel: np.ndarray | None = None
+    gyro: np.ndarray | None = None
+
+
+def _intrinsics_matrix(fx: float, fy: float, cx: float, cy: float) -> np.ndarray:
+    return np.array(
+        [
+            [fx, 0, cx, 0],
+            [0, fy, cy, 0],
+            [0, 0, 1, 0],
+        ],
+        dtype=np.float64,
+    )
+
+
+class PyZEDCameraHandle:
+    def __init__(
+        self,
+        camera: typing.Any,
+        device_info: ZEDDeviceInfo,
+        color_intrinsics: np.ndarray,
+        right_color_intrinsics: np.ndarray | None = None,
+    ):
+        self.camera = camera
+        self.device_info = device_info
+        self.color_intrinsics = color_intrinsics
+        self.right_color_intrinsics = right_color_intrinsics
+        self.runtime_parameters = sl.RuntimeParameters()  # type: ignore[union-attr]
+        self.image_mat = sl.Mat()  # type: ignore[union-attr]
+        self.right_image_mat = sl.Mat()  # type: ignore[union-attr]
+        self.depth_mat = sl.Mat()  # type: ignore[union-attr]
+        self.sensors_data = sl.SensorsData()  # type: ignore[union-attr]
+
+    def _timestamp_seconds(self) -> float:
+        try:
+            timestamp = self.camera.get_timestamp(sl.TIME_REFERENCE.IMAGE)  # type: ignore[union-attr]
+            if hasattr(timestamp, "get_nanoseconds"):
+                return float(timestamp.get_nanoseconds()) * 1e-9
+            if hasattr(timestamp, "get_microseconds"):
+                return float(timestamp.get_microseconds()) * 1e-6
+            if hasattr(timestamp, "get_milliseconds"):
+                return float(timestamp.get_milliseconds()) * 1e-3
+        except Exception:
+            pass
+        return time()
+
+    def grab_frame(self, include_right: bool = False) -> ZEDFrameBundle:
+        err = self.camera.grab(self.runtime_parameters)
+        if err != sl.ERROR_CODE.SUCCESS:  # type: ignore[union-attr]
+            msg = f"Failed to grab ZED frame: {err}"
+            raise RuntimeError(msg)
+
+        self.camera.retrieve_image(self.image_mat, sl.VIEW.LEFT)  # type: ignore[union-attr]
+        color_raw = np.array(self.image_mat.get_data(), copy=True)
+        if color_raw.ndim != 3:
+            msg = f"Unexpected ZED image shape {color_raw.shape}"
+            raise RuntimeError(msg)
+        color_rgb = color_raw[:, :, :3][:, :, ::-1] if color_raw.shape[2] == 4 else color_raw[:, :, ::-1]
+
+        right_color = None
+        if include_right:
+            self.camera.retrieve_image(self.right_image_mat, sl.VIEW.RIGHT)  # type: ignore[union-attr]
+            right_raw = np.array(self.right_image_mat.get_data(), copy=True)
+            if right_raw.ndim != 3:
+                msg = f"Unexpected ZED right image shape {right_raw.shape}"
+                raise RuntimeError(msg)
+            right_color = right_raw[:, :, :3][:, :, ::-1] if right_raw.shape[2] == 4 else right_raw[:, :, ::-1]
+
+        depth = None
+        if self.device_info.has_depth:
+            self.camera.retrieve_measure(self.depth_mat, sl.MEASURE.DEPTH)  # type: ignore[union-attr]
+            depth_raw = np.array(self.depth_mat.get_data(), copy=True)
+            if depth_raw.ndim > 2:
+                depth_raw = depth_raw[:, :, 0]
+            depth_m = np.nan_to_num(depth_raw, nan=0.0, posinf=0.0, neginf=0.0)
+            depth_m = np.clip(depth_m, a_min=0.0, a_max=np.iinfo(np.uint16).max / BaseCameraSet.DEPTH_SCALE)
+            depth = (depth_m * BaseCameraSet.DEPTH_SCALE).astype(np.uint16)
+
+        accel = None
+        gyro = None
+        if self.device_info.has_imu:
+            sensor_err = self.camera.get_sensors_data(self.sensors_data, sl.TIME_REFERENCE.IMAGE)  # type: ignore[union-attr]
+            if sensor_err == sl.ERROR_CODE.SUCCESS:  # type: ignore[union-attr]
+                imu_data = self.sensors_data.get_imu_data()
+                if hasattr(imu_data, "get_linear_acceleration"):
+                    accel = np.array(imu_data.get_linear_acceleration(), dtype=np.float64)
+                if hasattr(imu_data, "get_angular_velocity"):
+                    gyro = np.array(imu_data.get_angular_velocity(), dtype=np.float64)
+
+        return ZEDFrameBundle(
+            color=color_rgb,
+            right_color=right_color,
+            right_color_intrinsics=self.right_color_intrinsics if right_color is not None else None,
+            depth=depth,
+            accel=accel,
+            gyro=gyro,
+            timestamp=self._timestamp_seconds(),
+            color_intrinsics=self.color_intrinsics,
+        )
+
+    def close(self):
+        self.camera.close()
+
+
+class ZEDCameraSet(HardwareCamera):
+    CALIBRATION_FRAME_SIZE = 30
+
+    @staticmethod
+    def _require_sdk():
+        if sl is None:
+            msg = (
+                "The ZED SDK Python bindings are not available. Install the ZED SDK and ensure "
+                "`import pyzed.sl as sl` works on this machine."
+            )
+            raise RuntimeError(msg)
+
+    @staticmethod
+    def _device_has_imu(device: typing.Any) -> bool:
+        for attr in ("sensors_configuration", "sensors_conf"):
+            sensors_conf = getattr(device, attr, None)
+            if sensors_conf is None:
+                continue
+            camera_imu = getattr(sensors_conf, "camera_imu", None)
+            if camera_imu is None:
+                continue
+            if hasattr(camera_imu, "available"):
+                return bool(camera_imu.available)
+            return True
+        return False
+
+    @staticmethod
+    def _model_to_string(model: typing.Any) -> str:
+        if hasattr(model, "name"):
+            return str(model.name)
+        return str(model)
+
+    @staticmethod
+    def _map_resolution(width: int, height: int):
+        ZEDCameraSet._require_sdk()
+        assert sl is not None
+        mapping = {
+            (2208, 1242): sl.RESOLUTION.HD2K,
+            (1920, 1080): sl.RESOLUTION.HD1080,
+            (1280, 720): sl.RESOLUTION.HD720,
+            (672, 376): sl.RESOLUTION.VGA,
+        }
+        if (width, height) not in mapping:
+            msg = f"Unsupported ZED resolution {width}x{height}. Use one of: {sorted(mapping)}"
+            raise ValueError(msg)
+        return mapping[(width, height)]
+
+    @classmethod
+    def enumerate_connected_devices(cls) -> dict[str, ZEDDeviceInfo]:
+        cls._require_sdk()
+        assert sl is not None
+        devices: dict[str, ZEDDeviceInfo] = {}
+        for device in sl.Camera.get_device_list():
+            serial = str(device.serial_number)
+            devices[serial] = ZEDDeviceInfo(
+                serial=serial,
+                model=cls._model_to_string(device.camera_model),
+                has_depth=True,
+                has_imu=cls._device_has_imu(device),
+            )
+        return devices
+
+    @classmethod
+    def open_camera(
+        cls,
+        config: common.BaseCameraConfig,
+        *,
+        enable_depth: bool,
+        enable_imu: bool,
+        include_right: bool,
+    ) -> PyZEDCameraHandle:
+        cls._require_sdk()
+        assert sl is not None
+
+        init = sl.InitParameters()
+        init.camera_resolution = cls._map_resolution(config.resolution_width, config.resolution_height)
+        init.camera_fps = config.frame_rate
+        init.coordinate_units = sl.UNIT.METER
+        init.depth_mode = sl.DEPTH_MODE.NONE if not enable_depth else sl.DEPTH_MODE.QUALITY
+        init.set_from_serial_number(int(config.identifier))
+
+        camera = sl.Camera()
+        err = camera.open(init)
+        if err != sl.ERROR_CODE.SUCCESS:
+            msg = f"Could not open ZED camera {config.identifier}: {err}"
+            raise RuntimeError(msg)
+
+        information = camera.get_camera_information()
+        calibration = information.camera_configuration.calibration_parameters
+        left_cam = calibration.left_cam
+        right_cam = calibration.right_cam
+        info = ZEDDeviceInfo(
+            serial=str(config.identifier),
+            model=cls._model_to_string(information.camera_model),
+            has_depth=enable_depth,
+            has_imu=enable_imu and cls._device_has_imu(information),
+        )
+        intrinsics = _intrinsics_matrix(left_cam.fx, left_cam.fy, left_cam.cx, left_cam.cy)
+        right_intrinsics = None
+        if include_right:
+            right_intrinsics = _intrinsics_matrix(right_cam.fx, right_cam.fy, right_cam.cx, right_cam.cy)
+        return PyZEDCameraHandle(
+            camera=camera,
+            device_info=info,
+            color_intrinsics=intrinsics,
+            right_color_intrinsics=right_intrinsics,
+        )
+
+    def __init__(
+        self,
+        cameras: dict[str, common.BaseCameraConfig],
+        calibration_strategy: dict[str, CalibrationStrategy] | None = None,
+        enable_depth: bool = True,
+        enable_imu: bool = True,
+        include_right: bool = False,
+    ) -> None:
+        self.cameras = cameras
+        if calibration_strategy is None:
+            calibration_strategy = {camera_name: DummyCalibrationStrategy() for camera_name in cameras}
+        self.calibration_strategy = calibration_strategy
+        self.enable_depth = enable_depth
+        self.enable_imu = enable_imu
+        self.include_right = include_right
+        self._logger = logging.getLogger(__name__)
+        self._camera_names = self._logical_camera_names()
+        self._available_devices: dict[str, ZEDDeviceInfo] = {}
+        self._enabled_devices: dict[str, PyZEDCameraHandle] = {}
+        self._frame_buffer_lock: dict[str, threading.Lock] = {}
+        self._frame_buffer: dict[str, list[Frame]] = {}
+        self._pending_right_bundles: dict[str, ZEDFrameBundle] = {}
+
+        assert (
+            len({camera.resolution_width for camera in self.cameras.values()}) == 1
+            and len({camera.resolution_height for camera in self.cameras.values()}) == 1
+            and len({camera.frame_rate for camera in self.cameras.values()}) == 1
+        ), "All cameras must have the same resolution and frame rate."
+
+    @property
+    def camera_names(self) -> list[str]:
+        return self._camera_names
+
+    def config(self, camera_name) -> common.BaseCameraConfig:
+        return self.cameras[self._physical_camera_name(camera_name)]
+
+    @staticmethod
+    def _right_camera_name(camera_name: str) -> str:
+        return f"{camera_name}_right"
+
+    def _physical_camera_name(self, camera_name: str) -> str:
+        if camera_name in self.cameras:
+            return camera_name
+        if self.include_right and camera_name.endswith("_right"):
+            physical_name = camera_name.removesuffix("_right")
+            if physical_name in self.cameras:
+                return physical_name
+        msg = f"Camera {camera_name} not found in the enabled devices"
+        raise AssertionError(msg)
+
+    def _is_right_camera_name(self, camera_name: str) -> bool:
+        return camera_name not in self.cameras and self._physical_camera_name(camera_name) != camera_name
+
+    def _logical_camera_names(self) -> list[str]:
+        names = list(self.cameras.keys())
+        if self.include_right:
+            names.extend(self._right_camera_name(camera_name) for camera_name in self.cameras)
+        return names
+
+    def _frame_from_bundle(self, camera_name: str, bundle: ZEDFrameBundle) -> Frame:
+        physical_name = self._physical_camera_name(camera_name)
+        extrinsics = self.calibration_strategy[physical_name].get_extrinsics()
+        is_right = self._is_right_camera_name(camera_name)
+        color_data = bundle.right_color if is_right else bundle.color
+        color_intrinsics = bundle.right_color_intrinsics if is_right else bundle.color_intrinsics
+        if color_data is None or color_intrinsics is None:
+            msg = f"Missing {'right' if is_right else 'left'} image data for {camera_name}"
+            raise RuntimeError(msg)
+
+        color = DataFrame(
+            data=color_data,
+            timestamp=bundle.timestamp,
+            intrinsics=color_intrinsics,
+            extrinsics=extrinsics,
+        )
+        depth = None
+        if not is_right and bundle.depth is not None:
+            depth = DataFrame(
+                data=bundle.depth,
+                timestamp=bundle.timestamp,
+                intrinsics=bundle.color_intrinsics,
+                extrinsics=extrinsics,
+            )
+
+        accel = DataFrame(data=bundle.accel, timestamp=bundle.timestamp) if bundle.accel is not None else None
+        gyro = DataFrame(data=bundle.gyro, timestamp=bundle.timestamp) if bundle.gyro is not None else None
+        return Frame(
+            camera=CameraFrame(color=color, depth=depth),
+            imu=IMUFrame(accel=accel, gyro=gyro) if (accel is not None or gyro is not None) else None,
+            avg_timestamp=bundle.timestamp,
+        )
+
+    def update_available_devices(self):
+        self._available_devices = self.enumerate_connected_devices()
+
+    def open(self):
+        self.update_available_devices()
+        self._enabled_devices = {}
+        self._frame_buffer = {}
+        self._frame_buffer_lock = {}
+        self._pending_right_bundles = {}
+
+        for camera_name, camera_cfg in self.cameras.items():
+            if camera_cfg.identifier not in self._available_devices:
+                msg = f"ZED device {camera_name} with serial {camera_cfg.identifier} not found."
+                raise RuntimeError(msg)
+
+            device_info = self._available_devices[camera_cfg.identifier]
+            opened = self.open_camera(
+                camera_cfg,
+                enable_depth=self.enable_depth and device_info.has_depth,
+                enable_imu=self.enable_imu and device_info.has_imu,
+                include_right=self.include_right,
+            )
+            self._enabled_devices[camera_name] = opened
+            self._frame_buffer[camera_name] = []
+            self._frame_buffer_lock[camera_name] = threading.Lock()
+
+    def poll_frame(self, camera_name: str) -> Frame:
+        assert camera_name in self.camera_names, f"Camera {camera_name} not found in the enabled devices"
+        physical_name = self._physical_camera_name(camera_name)
+        device = self._enabled_devices[physical_name]
+
+        if self._is_right_camera_name(camera_name):
+            bundle = self._pending_right_bundles.pop(physical_name, None)
+            if bundle is None:
+                bundle = device.grab_frame(include_right=True)
+        else:
+            bundle = device.grab_frame(include_right=self.include_right)
+            if self.include_right and bundle.right_color is not None:
+                self._pending_right_bundles[physical_name] = bundle
+            else:
+                self._pending_right_bundles.pop(physical_name, None)
+
+        frame = self._frame_from_bundle(camera_name, bundle)
+
+        if not self._is_right_camera_name(camera_name):
+            with self._frame_buffer_lock[physical_name]:
+                if len(self._frame_buffer[physical_name]) >= self.CALIBRATION_FRAME_SIZE:
+                    self._frame_buffer[physical_name].pop(0)
+                self._frame_buffer[physical_name].append(copy.deepcopy(frame))
+        return frame
+
+    def close(self):
+        for device in self._enabled_devices.values():
+            device.close()
+        self._enabled_devices = {}
+        self._pending_right_bundles = {}
+
+    def calibrate(self) -> bool:
+        for camera_name in self.cameras:
+            device = self._enabled_devices.get(camera_name)
+            if device is None:
+                msg = f"Camera {camera_name} must be opened before calibration."
+                raise RuntimeError(msg)
+            if not self.calibration_strategy[camera_name].calibrate(
+                intrinsics=device.color_intrinsics,
+                samples=self._frame_buffer[camera_name],
+                lock=self._frame_buffer_lock[camera_name],
+            ):
+                self._logger.warning("Calibration of camera %s failed.", camera_name)
+                return False
+        self._logger.info("Calibration successful.")
+        return True

rcs_zed/utils.py

@@ -0,0 +1,30 @@
+from rcs.camera.hw import CalibrationStrategy
+from rcs_zed.camera import ZEDCameraSet
+
+from rcs import common
+
+
+def default_zed(
+    name2id: dict[str, str] | None,
+    calibration_strategy: dict[str, CalibrationStrategy] | None = None,
+) -> ZEDCameraSet | None:
+    """Create the default ZED camera set.
+
+    Args:
+        name2id: Mapping from logical camera names to ZED serial numbers.
+        calibration_strategy: Optional calibration strategy for each logical
+            camera. When omitted, ``ZEDCameraSet`` uses
+            ``DummyCalibrationStrategy``.
+    """
+    if name2id is None:
+        return None
+    cameras = {
+        name: common.BaseCameraConfig(identifier=id, resolution_width=1280, resolution_height=720, frame_rate=30)
+        for name, id in name2id.items()
+    }
+    return ZEDCameraSet(cameras=cameras, calibration_strategy=calibration_strategy)
+
+
+def default_zed_dummy_calibration(name2id: dict[str, str] | None) -> ZEDCameraSet | None:
+    """Create the default ZED camera set with dummy calibration."""
+    return default_zed(name2id)

rcs_zed-0.7.3.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: rcs_zed
+Version: 0.7.3
+Summary: RCS ZED camera module
+Author-email: Tobias Juelg <tobias.juelg@utn.de>
+Maintainer-email: Tobias Juelg <tobias.juelg@utn.de>
+License-Expression: AGPL-3.0-or-later
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: rcs-core>=0.7.3
+Requires-Dist: opencv-python~=4.10.0
+Requires-Dist: typer~=0.9
+
+# RCS ZED Extension
+
+Support for Stereolabs ZED cameras in RCS.
+
+This extension depends on [`rcs-core`](https://pypi.org/project/rcs-core/).
+Documentation: <https://robotcontrolstack.org/extensions/rcs_zed>
+
+## Installation
+
+- You need a PC with an Nvidia GPU and CUDA 12.8 installed.
+- Install the ZED SDK from [Stereolabs](https://www.stereolabs.com/en-fr/developers/release).
+- Install the Python bindings from the [zed-python-api](https://github.com/stereolabs/zed-python-api).
+
+Install from PyPI:
+
+```shell
+pip install rcs-zed
+```
+
+Warning: plain `pip install rcs-zed` will install the published `rcs-core` dependency from PyPI.
+
+Install from a local checkout:
+
+```shell
+pip install -ve .
+```
+
+If you want this extension to use your local RCS checkout instead of the published `rcs-core` package, first install the main package from the repository root:
+
+```shell
+pip install -ve . --no-build-isolation
+pip install -ve extensions/rcs_zed
+```
+
+## Calibration
+
+`default_zed(...)` is standalone and uses RCS's identity
+`DummyCalibrationStrategy` by default. To use measured extrinsics, pass one
+calibration strategy per logical camera:
+
+```python
+from rcs_zed.utils import default_zed
+
+calibration = {
+    "wrist": my_wrist_calibration,
+    "scene": my_scene_calibration,
+}
+cameras = default_zed(
+    {"wrist": "12345678", "scene": "87654321"},
+    calibration_strategy=calibration,
+)
+```
+
+Each value must implement the `rcs.camera.hw.CalibrationStrategy` protocol.
+This keeps ZED installation independent of other camera extensions and lets
+applications choose the calibration method that matches their robot setup.
+
+## CLI
+
+```shell
+python -m rcs_zed serials
+python -m rcs_zed rgb-view
+```
+
+## Permissions
+
+```shell
+sudo usermod -a -G video,plugdev $USER
+```
+
+## Connection Diagnostics
+
+- Use `ZED_Diagnostic` first if something appears broken.
+- See the Stereolabs USB troubleshooting guide: <https://support.stereolabs.com/hc/en-us/articles/207635225-How-to-fix-USB-3-0-bandwidth-and-connection-issues>

rcs_zed-0.7.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+rcs_zed/__init__.py,sha256=zYiFHqR7JwbvdK9dvKrh-RTNfUqjHUwC4CTcFAPVYLc,22
+rcs_zed/__main__.py,sha256=HKNRK9a7mB4Kz4a26i4FUanU6SvgUX2Yrrzlj2N3D64,6683
+rcs_zed/camera.py,sha256=vk0vrXaw-5QgARWpSI4KpflDLv0IoQyI51vaa5Sg_Mw,16858
+rcs_zed/utils.py,sha256=okg3d9zG2qPFuEiUa_soPJBEep3PdL_OhLe2vv3Uu0g,1069
+rcs_zed-0.7.3.dist-info/METADATA,sha256=GBqNphMRwquVyAF0Q3oPORnQeB04tF2J1ZeXKoUxceA,2390
+rcs_zed-0.7.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+rcs_zed-0.7.3.dist-info/top_level.txt,sha256=rB0upoLlwl3ScEYrtGOepN6GBzKZkDDHmAq9d8lIN0Q,8
+rcs_zed-0.7.3.dist-info/RECORD,,

rcs_zed-0.7.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rcs_zed-0.7.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+rcs_zed