> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.stereolabs.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.stereolabs.com/_mcp/server.

# Setting up the ZED X One for Monocular Vision

This guide explains how to set up a **ZED X One** camera for monocular vision on an NVIDIA® Jetson™ platform and use it to retrieve image and inertial data.

## Install the GMSL2 driver

> **Warning**
>
> **Important**: This procedure is valid only for [ZED Box Orin](/docs/products/embedded/zed-box-orin/), [ZED Box Mini](/docs/products/embedded/zed-box-mini/), or official NVIDIA® Jetson™ development kit platforms equipped with a [ZED Link GMSL2 Capture Card](/docs/products/embedded/zed-link-capture-card/gmsl2/). If you are using a different [GMSL2](/docs/products/embedded/zed-link-capture-card/gmsl2#what-is-gmsl2) system, please refer to the specific installation instructions provided by your hardware manufacturer.

ZED X One cameras require a **[GMSL2](/docs/products/embedded/zed-link-capture-card/gmsl2#what-is-gmsl2) driver** to operate correctly. This driver configures the [GMSL2](/docs/products/embedded/zed-link-capture-card/gmsl2#what-is-gmsl2) device and is hardware-dependent.

Download the appropriate driver from the [ZED X Driver download page](https://www.stereolabs.com/developers/drivers).

> **Note**
>
> Always verify the latest driver version available on the [download page](https://www.stereolabs.com/developers/drivers). We recommend installing the most recent version.

Select the driver matching your hardware configuration and install it:

```bash
sudo dpkg -i stereolabs-<board>_X.X.X-<deserializer>-L4TZZ.Z.Z_arm64.deb
```

Where:

* `X.X.X` is the driver version
* `<board>` is the board model
* `<deserializer>` is the deserializer type
* `L4TZZ.Z.Z` is the Jetson™ Linux version (corresponding to your JetPack version)

**Example**: For ZED X Driver v1.3.2 on L4T 36.4.3 (JetPack 6.2) with the StereoLabs ZED Link Duo [GMSL2](/docs/products/embedded/zed-link-capture-card/gmsl2#what-is-gmsl2) Capture Card (driver packages for L4T 36.4.x use the `L4T36.4.0` suffix):

```bash
sudo dpkg -i stereolabs-zedlink-duo_1.3.2-LI-MAX96712-all-L4T36.4.0_arm64.deb
```

> **Note**
>
> If the installation fails due to missing dependencies, install `libqt5core5a`:
>
> ```bash
> sudo apt install libqt5core5a
> ```

After installation, **reboot** your NVIDIA® Jetson™ platform.

For troubleshooting, refer to the [ZED Link troubleshooting guide](/docs/products/embedded/zed-link-capture-card/gmsl2/troubleshooting/).

## Use the ZED X One with the ZED SDK

The ZED SDK includes built-in support for data acquisition from a ZED X One camera for monocular vision using the `sl::CameraOne` class, allowing you to open and manage the camera directly through the SDK without relying on external tools.

### Install the ZED SDK

The [ZED SDK](/docs/development/zed-sdk/) enables processing of image data from ZED X One cameras in monocular mode. The `sl::CameraOne` class provides the core functionality to retrieve raw and rectified images, as well as inertial data.

To get started, [download and install the ZED SDK on your NVIDIA® Jetson™ platform](/docs/development/zed-sdk/linux/work-with-nvidia-jetson/).

### Sample code to open and use the ZED X One camera for monocular vision

**`C++`**

```cpp C++
#include <sl/CameraOne.hpp>

using namespace sl;

InitParametersOne init_parameters;

// Set any InitParametersOne as needed to configure the camera settings

sl::CameraOne zed_one;

// Open the camera
ERROR_CODE err = zed_one.open(init_parameters);
if (err != ERROR_CODE::SUCCESS)
    exit(-1);

Mat bgra;

while (!exit_app) {
    if (zed_one.grab() == ERROR_CODE::SUCCESS) {
        zed_one.retrieveImage(bgra); // Retrieve the BGRA image (default format)

        // Any processing
    }
}
// Close the camera
zed_one.close();
```

**`Python`**

```python Python
import pyzed.sl as sl

zed_one = sl.CameraOne()

init = sl.InitParametersOne()

# Set any InitParametersOne as needed to configure the camera settings

# Open the camera
err = zed_one.open(init)
if err != sl.ERROR_CODE.SUCCESS:
    exit(1)

bgra = sl.Mat()

while not exit_app:
    if zed_one.grab() == sl.ERROR_CODE.SUCCESS:
        zed_one.retrieve_image(bgra)  # Retrieve the BGRA image (default format)
        # Any processing

# Close the camera
zed_one.close()
```

For more details on using the ZED SDK with monocular ZED X One cameras, refer to the [ZED SDK API documentation](https://www.stereolabs.com/docs/api/).

## Use the ZED X One with NVIDIA® Libargus Camera API

The camera can be opened using the [Libargus Camera API](https://docs.nvidia.com/jetson/l4t-multimedia/group__LibargusAPI.html), the API provided by NVIDIA® on Jetson™ to open cameras connected via [GMSL2](/docs/products/embedded/zed-link-capture-card/gmsl2#what-is-gmsl2) and CSI.

Make sure the multimedia API is installed:

```bash
sudo apt install nvidia-l4t-jetson-multimedia-api
```

Then compile the camera sample:

```bash
cp -r /usr/src/jetson_multimedia_api/* ./
sudo apt install libgtk-3-dev
cd argus
mkdir build && cd build && cmake .. && make
cp apps/camera/ui/camera/argus_camera ./
./argus_camera
```

## Use the ZED X One with GStreamer

### Use the StereoLabs `zedxonesrc` source element

Please refer to the [ZED GStreamer plugin documentation](/docs/integrations/gstreamer/zed-x-one-camera-source-element/) to leverage the full capabilities of the ZED X One camera.

### Use the NVIDIA® `nvarguscamerasrc` source element

To open the camera using the nvarguscamera GStreamer plugin, run:

```bash
gst-launch-1.0 nvarguscamerasrc sensor-id=0 ! 'video/x-raw(memory:NVMM), width=(int)1920, height=(int)1200, framerate=30/1' ! nvvidconv flip-method=0 ! 'video/x-raw, format=(string)I420' ! xvimagesink -e
```

Please refer to the [NVIDIA® documentation](https://docs.nvidia.com/jetson/archives/r36.4.3/DeveloperGuide/SD/Multimedia/AcceleratedGstreamer.html) for more information.

## Use the ZED X One with the open source driver ZED X Open Capture

To use the ZED X One capture open source API, go to [https://github.com/stereolabs/zedx-one-capture](https://github.com/stereolabs/zedx-one-capture).

Compile the library, then modify the sample to fit your application.

The library is based on the multimedia API from NVIDIA®.

> **Note**
>
> Support for retrieving IMU data will be available in a future release.

## Use the ZED X One with ROS 2

The [ZED ROS 2 wrapper](/docs/integrations/ros-2/) supports monocular ZED X One data publishing.

When launching the ZED ROS 2 node, set the `camera_model` parameter to one of the available models: `zedxonegs`, `zedxone4k`. For example:

```bash
ros2 launch zed_wrapper zed_camera.launch.py camera_model:=zedxonegs
```

or

```bash
ros2 launch zed_wrapper zed_camera.launch.py camera_model:=zedxone4k
```

For more details on using the ZED ROS 2 wrapper, refer to the [ZED ROS 2 documentation](/docs/integrations/ros-2/).

## Calibrate the ZED X One for monocular vision

ZED X One cameras purchased with optics are factory calibrated, and no further action is required to retrieve undistorted, metrically accurate images. However, you need to calibrate the camera yourself when:

* the camera was purchased without optics and you install your own custom lens;
* the camera is used in particular conditions that alter its optical behavior, such as underwater or behind a glass that acts as an additional lens.

In these cases, you can calibrate the camera with the open source [`zed-opencv-calibration`](https://github.com/stereolabs/zed-opencv-calibration) tools. The `zed_mono_calibration` tool computes the camera's intrinsic parameters (focal length, principal point, and distortion coefficients) from multiple views of a checkerboard pattern.

### Prerequisites

* [ZED SDK](/docs/products/cameras/zedxone/monocular-vision#install-the-zed-sdk) 5.1 or later
* OpenCV 4.x
* CUDA (compatible with your ZED SDK version)
* OpenGL libraries (GLEW, FreeGLUT)
* CMake 3.5+ and a C++17 compiler
* A printed checkerboard pattern with known square size and inner-edge counts

### Build the calibration tools

```bash
git clone https://github.com/stereolabs/zed-opencv-calibration.git
cd zed-opencv-calibration
mkdir build && cd build
cmake ..
make -j$(nproc)
```

### Run the calibration

If you don't know the serial number or ID of your camera, list the connected devices with:

```bash
ZED_Explorer --all
```

Then launch the calibration tool:

```bash
cd build/monocular_calibration/
./zed_mono_calibration
```

![image](/_fern-img/a1bebf1166b4de0b3456c5d97b8c81ad6b5ec1e8cbae1200b2c0e25c2ab4e8f9.webp)

The tool accepts the following parameters:

| Parameter               | Description                                       |
| ----------------------- | ------------------------------------------------- |
| `--h_edges <value>`     | Horizontal inner edges of the checkerboard        |
| `--v_edges <value>`     | Vertical inner edges of the checkerboard          |
| `--square_size <value>` | Square size in millimeters                        |
| `--svo <file>`          | Path to an SVO file to calibrate from a recording |
| `--fisheye`             | Use the fisheye lens model                        |
| `--id <id>`             | Camera ID of the ZED X One                        |
| `--sn <sn>`             | Serial number of the ZED X One                    |
| `--help`, `-h`          | Display the help message                          |

For example, to calibrate a fisheye lens using a 12×9 checkerboard with 30 mm squares:

```bash
./zed_mono_calibration --fisheye --h_edges 12 --v_edges 9 --square_size 30.0
```

The calibration runs in two phases:

1. **Data acquisition**: Move the checkerboard in front of the camera and press **Spacebar** or **S** to capture each frame. The tool enforces quality checks (sharpness, diversity) and provides real-time feedback on X/Y coverage, size range, and skew.
2. **Calibration computation**: Computation triggers automatically once all metrics reach 100% with the minimum number of samples, or when the maximum sample count is reached.

When complete, the tool writes two files:

* `mono_calibration_SN<serial_number>.yml`: OpenCV format containing the camera matrix (K) and distortion coefficients.
* `SN<serial_number>_mono.conf`: ZED-compatible format covering all supported resolutions.

> **Note**
>
> To let the ZED SDK use your calibration automatically for the corresponding camera, copy the generated `.conf` file into the `settings` folder of your ZED SDK installation:
>
> * **Linux**: `/usr/local/zed/settings/`
> * **Windows**: `C:\ProgramData\StereoLabs\settings\`
>
> The file must be renamed to follow the `SNxxxxxxxx.conf` convention, where `xxxxxxxx` is the camera serial number (for example, `SN10025660.conf`).

> **Note**
>
> On **Windows**, a ZED X One camera cannot be connected and used directly, since the [GMSL2](/docs/products/embedded/zed-link-capture-card/gmsl2#what-is-gmsl2) driver requires an NVIDIA® Jetson™ platform. You can still work with ZED X One data on Windows by playing back **SVO2 recordings** or by receiving a **local network stream** from a Jetson™ device. In these cases the `.conf` calibration file must be copied manually into the `C:\ProgramData\StereoLabs\settings\` folder, following the `SNxxxxxxxx.conf` naming convention described above.

### Validate the calibration with `zed_mono_checker`

After calibrating, use the `zed_mono_checker` tool to verify the result. It measures the reprojection error in real time against the detected checkerboard corners, giving you immediate feedback on calibration quality.

```bash
cd build/monocular_checker/
./zed_mono_checker
```

![image](/_fern-img/c2debde65a28285c3cc8bc958538879e539c47e1df346b0b5d9e3e233a294a21.webp)

By default, the checker uses the camera's internal calibration. To validate a specific calibration file, pass it with `--calib_opencv`:

```bash
./zed_mono_checker --calib_opencv mono_calibration_SN12345678.yml
```

The checker accepts the same camera, checkerboard, and lens parameters as the calibration tool, plus:

| Parameter               | Description                                        |
| ----------------------- | -------------------------------------------------- |
| `--calib_opencv <file>` | Path to a custom calibration YAML file to validate |

The reprojection error is displayed and color-coded:

* **Green**: below 0.5 px (good)
* **Orange**: 0.5–1.0 px (acceptable)
* **Red**: above 1.0 px (poor; recalibration recommended)

If the error is consistently in the red range, run `zed_mono_calibration` again, taking care to cover the full field of view with diverse checkerboard poses.