Setting up the ZED X One Core for Monocular Vision

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

Install the ZED Link MIPI driver

The ZED X One Core requires a ZED Link MIPI driver to operate correctly. This driver configures the MIPI capture pipeline of the card and of the connected cameras, and it is distributed separately from the GMSL2 ZED Link driver.

Download the package matching your capture card and your Jetson™ Linux (L4T) version from the ZED X Camera Drivers page, install it with dpkg, and reboot the Developer Kit.

The full assembly and driver installation procedure is described in the ZED Link MIPI Quad on AGX Orin setup guide.

For troubleshooting, refer to the MIPI Troubleshooting guide.

Focus the lens (custom optics only)

Focusing is only required on a camera purchased without optics, on which you mount your own lens. Mount the camera in its final position, open a live preview with ZED_Explorer or ZED_Studio, and adjust the lens until the image is sharp at the working distance of your application. Lock the lens in place once focus is correct: any later movement of the optics invalidates the calibration.

Use the ZED X One Core with the ZED SDK

Once the capture card driver is installed, the ZED X One Core is handled by the ZED SDK like any other ZED X One camera. The SDK includes built-in support for data acquisition from a single camera through the sl::CameraOne class, allowing you to open and manage the camera directly without relying on external tools.

Install the ZED SDK

The ZED SDK enables processing of image data from the ZED X One Core in monocular mode. The sl::CameraOne class provides the core functionality to retrieve raw and rectified images, as well as inertial data from the integrated BMI088 IMU.

To get started, download and install the ZED SDK on your NVIDIA® Jetson™ platform.

Verify that the cameras are enumerated, with ZED_Explorer or ZED_Studio:

ZED_Explorer --all
ZED_Studio --list

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

#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();

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

Use the ZED X One Core 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 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 Core with ROS 2

The ZED ROS 2 wrapper supports monocular ZED X One Core data publishing.

When launching the ZED ROS 2 node, set the camera_model parameter to zedxonecore:

ros2 launch zed_wrapper zed_camera.launch.py camera_model:=zedxonecore

For more details on using the ZED ROS 2 wrapper, refer to the ZED ROS 2 documentation.

Calibrate the ZED X One Core for monocular vision

ZED X One Core cameras purchased with optics are factory calibrated, and no further action is required to retrieve undistorted, metrically accurate images. You need to calibrate the camera yourself only in custom configurations:

• the camera was purchased without optics and you install your own custom lens;
• the lens is replaced, refocused, or moved in any way;
• the camera is used in 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 v5.5 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
• A focused and mechanically locked lens

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:

Use --fisheye with the fisheye lens option of the ZED X One Core. The wide and narrow lens options use the default pinhole model.

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, check that the lens is still firmly locked, then run zed_mono_calibration again, taking care to cover the full field of view with diverse checkerboard poses.