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

ZED X One cameras require a GMSL2 driver to operate correctly. This driver configures the GMSL2 device and is hardware-dependent.

Download the appropriate driver from the ZED X Driver download page.

Select the driver matching your hardware configuration and install it:

$
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.0 (JetPack 6.2) with the StereoLabs ZED Link Duo GMSL2 Capture Card:

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

$
sudo apt install libqt5core5a

After installation, reboot your NVIDIA® Jetson™ platform.

For troubleshooting, refer to the ZED Link troubleshooting guide.

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 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.

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

1
#include <sl/CameraOne.hpp>
2
3
using namespace sl;
4
5
// Set the input from stream
6
InitParametersOne init_parameters;
7
8
// Set any InitParametersOne as needed to configure the camera settings
9
10
sl::CameraOne zed_one;
11
12
// Open the camera
13
ERROR_CODE err = zed_one.open(init_parameters);
14
if (err != ERROR_CODE::SUCCESS)
15
    exit(-1);
16
17
Mat bgra;
18
19
while (!exit_app) {
20
    if (zed_one.grab() == ERROR_CODE::SUCCESS) {
21
        zed_one.retrieveImage(bgra); // Retrieve the BGRA image (default format)
22
23
        // Any processing
24
    }
25
}
26
// Close the camera
27
zed_one.close();

For more details on using the ZED SDK with monocular ZED X One cameras, refer to the ZED SDK API documentation.

Use the ZED X One with NVIDIA® Libargus Camera API

The camera can be opened using the Libargus Camera API, the API provided by NVIDIA® on Jetson™ to open cameras connected via GMSL2 and CSI.

Make sure the multimedia API is installed:

$
sudo apt install nvidia-l4t-jetson-multimedia-api

Then compile the camera sample:

$
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 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:

$
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 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.

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

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

Use the ZED X One with ROS 2

The ZED ROS 2 wrapper 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:

$
ros2 launch zed_wrapper zed_camera.launch.py camera_model:=zedxonegs

or

$
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.

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 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 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

$
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:

$
ZED_Explorer --all

Then launch the calibration tool:

$
cd build/monocular_calibration/
$
./zed_mono_calibration

The tool accepts the following parameters:

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

$
./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.

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.

$
cd build/monocular_checker/
$
./zed_mono_checker

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

$
./zed_mono_checker --calib_opencv mono_calibration_SN12345678.yml

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

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.