InitParameters Class Reference

Holds the options used to initialize the Camera object.
Once passed to the Camera::open() function, these settings will be set for the entire execution life time of the Camera.
You can get further information in the detailed description bellow.
. More...

General Functions

 InitParameters (RESOLUTION camera_resolution_=RESOLUTION_HD720, int camera_fps_=0, int camera_linux_id_=0, String svo_input_filename_=String(), bool svo_real_time_mode_=false, DEPTH_MODE depth_mode_=DEPTH_MODE_PERFORMANCE, UNIT coordinate_units_=UNIT_MILLIMETER, COORDINATE_SYSTEM coordinate_system_=COORDINATE_SYSTEM_IMAGE, bool sdk_verbose_=false, int sdk_gpu_id_=-1, float depth_minimum_distance_=-1., bool camera_disable_self_calib_=false, bool camera_image_flip_=false, bool enable_right_side_measure_=false, int camera_buffer_count_linux_=4, String sdk_verbose_log_file_=String(), int depth_stabilization_=1, CUcontext sdk_cuda_ctx_=CUcontext(), InputType input_type=InputType(), String opt_path_=String())
 Default constructor. All the parameters are set to their default and optimized values. More...
bool save (String filename)
bool load (String filename)


RESOLUTION camera_resolution
int camera_fps
int camera_image_flip
bool camera_disable_self_calib
bool enable_right_side_measure
int camera_buffer_count_linux
int camera_linux_id
String svo_input_filename
bool svo_real_time_mode
DEPTH_MODE depth_mode
int depth_stabilization
float depth_minimum_distance
UNIT coordinate_units
COORDINATE_SYSTEM coordinate_system
CUdevice sdk_gpu_id
bool sdk_verbose
String sdk_verbose_log_file
CUcontext sdk_cuda_ctx
InputType input
String optional_settings_path

Detailed Description

Holds the options used to initialize the Camera object.
Once passed to the Camera::open() function, these settings will be set for the entire execution life time of the Camera.
You can get further information in the detailed description bellow.

This structure allows you to select multiple parameters for the Camera such as the selected camera, its resolution, depth mode, coordinate system, and unit, of measurement. Once filled with the desired options, it should be passed to the Camera::open function.

#include <sl/Camera.hpp>
using namespace sl;
int main(int argc, char **argv) {
Camera zed; // Create a ZED camera object
InitParameters init_params; // Set initial parameters
init_params.sdk_verbose = false; // Disable verbose mode
init_params.camera_resolution = RESOLUTION_HD1080; // Use HD1080 video mode
init_params.camera_fps = 30; // Set fps at 30
// Other parameters are left to their default values
// Open the camera
if (err != SUCCESS)
// Close the camera
return 0;

With its default values, it opens the ZED camera in live mode at RESOLUTION_HD720 and sets the depth mode to DEPTH_MODE_PERFORMANCE.
You can customize it to fit your application. The parameters can also be saved and reloaded using its save() and load() functions.

Constructor and Destructor

InitParameters ( RESOLUTION  camera_resolution_ = RESOLUTION_HD720,
int  camera_fps_ = 0,
int  camera_linux_id_ = 0,
String  svo_input_filename_ = String(),
bool  svo_real_time_mode_ = false,
UNIT  coordinate_units_ = UNIT_MILLIMETER,
bool  sdk_verbose_ = false,
int  sdk_gpu_id_ = -1,
float  depth_minimum_distance_ = -1.,
bool  camera_disable_self_calib_ = false,
bool  camera_image_flip_ = false,
bool  enable_right_side_measure_ = false,
int  camera_buffer_count_linux_ = 4,
String  sdk_verbose_log_file_ = String(),
int  depth_stabilization_ = 1,
CUcontext  sdk_cuda_ctx_ = CUcontext(),
InputType  input_type = InputType(),
String  opt_path_ = String() 

Default constructor. All the parameters are set to their default and optimized values.


bool save ( String  filename)

This function saves the current set of parameters into a file to be reloaded with the load() function.

filename: the path to the file in which the parameters will be stored.
True if file was successfully saved, otherwise false.
InitParameters init_params; // Set initial parameters
init_params.sdk_verbose = True; // Enable verbose mode
init_params.input.setFromSVOFile("/path/to/file.svo"); // Selects the and SVO file to be read"initParameters.conf"); // Export the parameters into a file
bool load ( String  filename)

This function set the other parameters from the values contained in a previously saved file.

filename: the path to the file from which the parameters will be loaded.
True if the file was successfully loaded, otherwise false.
InitParameters init_params; // Set initial parameters
init_params.load("initParameters.conf"); // Load the init_params from a previously exported file
As the InitParameters files can be easilly modified manually (using a text editor) this functions allows you to test various settings without re-compiling your application.


RESOLUTION camera_resolution

Define the chosen camera resolution. Small resolutions offer higher framerate and lower computation time.
In most situations, the RESOLUTION_HD720 at 60 fps is the best balance between image quality and framerate.
Available resolutions are listed here: RESOLUTION.
default : RESOLUTION_HD720

int camera_fps

Requested camera frame rate. If set to 0, the highest FPS of the specified camera_resolution will be used.
See RESOLUTION for a list of supported framerates.
default : 0

If the requested camera_fps is unsuported, the closest available FPS will be used.
int camera_image_flip

If you are using the camera upside down, setting this parameter to true will cancel its rotation. The images will be horizontally flipped.
default : false

bool camera_disable_self_calib

At initialization, the Camera runs a self-calibration process that corrects small offsets from the device's factory calibration.
A drawback is that calibration parameters will sligtly change from one run to another, which can be an issue for repeatability.
If set to true, self-calibration will be disabled and calibration parameters won't be optimized.
default : false

In most situations, self calibration should remain enabled.
bool enable_right_side_measure

By default, the SDK only computes a single depth map, aligned with the left camera image.
This parameter allows you to enable the MEASURE_DEPTH_RIGHT and other MEASURE_<XXX>_RIGHT at the cost of additional computation time.
For example, mixed reality passthrough applications require one depth map per eye, so this parameter can be activated.
default : false

int camera_buffer_count_linux

Images coming from the camera will be saved in a FIFO buffer waiting for the program to call the Camera::grab() function.
On Linux Desktop : This parameter sets the buffer size between 2 and 5. Low values will reduce the latency but can also produce more corrupted frames.
On Jetson Boards : This parameter is fixed to 2 for memory and performance optimizations.
On Windows Desktop : The images aren't buffered, so this parameter won't be interpreted.

default: 4 on Linux Desktop, 2 on Jetson.

Linux Desktop Only, changing this parameter has no effect on Windows or Jetson boards.
int camera_linux_id

Only for Linux : This parameter allows you to select the ZED device to be opened when multiple cameras are connected. This ID matches the system ID found in /dev/videoX.
default : 0

This parameters is deprecated, please check input for a cross-platform and more powerful system.
String svo_input_filename

The Camera object can be used with a live ZED or a recorded sequence saved in an SVO file.
This parameter allows you to specify the path to the recorded sequence to be played back.
default : (empty)

If this parameter remains empty, the SDK will attempt to open a live camera. Setting it to any value will disable live mode.
This parameter has been deprecated with the introduction of input. Please use input.setFromSVOFile("path/to/my/file.svo") instead.
bool svo_real_time_mode

When playing back an SVO file, each call to Camera::grab() will extract a new frame and use it.
However, this ignores the real capture rate of the images saved in the SVO file.
Enabling this parameter will bring the SDK closer to a real simulation when playing back a file by using the images' timestamps. However, calls to Camera::grab() will return an error when trying to play to fast, and frames will be dropped when playing too slowly.

default : false

DEPTH_MODE depth_mode

The SDK offers several DEPTH_MODE options offering various level of performance and accuracy.
This parameter allows you to set the DEPTH_MODE that best matches your needs.

int depth_stabilization

Regions of the generated depth map can oscillate from one frame to another. These oscillations result from a lack of texture (too homogeneous) on an object and by image noise.
This parameter enables a stabilization filter that reduces these oscilations.
default : true

The stabilization uses the positional tracking to increase its accuracy, so the Tracking module will be enabled automatically when set to true.
Notice that calling Camera::enableTracking with your own parameters afterward is still possible.
float depth_minimum_distance

This parameter allows you to specify the minimum depth value (from the camera) that will be computed, measured in the UNIT you define.
In stereovision (the depth technology used by the camera), looking for closer depth values can have a slight impact on performance. However, this difference is almost invisible on modern GPUs.
In cases of limited computation power, increasing this value can provide better performance.
default : (-1) corresponding to 700 mm for a ZED and 200 mm for ZED Mini.

With a ZED camera you can decrease this value to 300 mm whereas you can set it to 100 mm using a ZED Mini. In any case this value cannot be greater than 3 meters.
UNIT coordinate_units

This parameter allows you to select the unit to be used for all metric values of the SDK. (depth, point cloud, tracking, mesh, and others).

COORDINATE_SYSTEM coordinate_system

Positional tracking, point clouds and many other features require a given COORDINATE_SYSTEM to be used as reference. This parameter allows you to select the COORDINATE_SYSTEM use by the Camera to return its measures.
This defines the order and the direction of the axis of the coordinate system.

CUdevice sdk_gpu_id

By default the SDK will use the most powerful NVIDIA graphics card found. However, when running several applications, or using several cameras at the same time, splitting the load over available GPUs can be useful. This parameter allows you to select the GPU used by the Camera using an ID from 0 to n-1 GPUs in your PC.
default : -1

A non-positive value will search for all CUDA capable devices and select the most powerful.
bool sdk_verbose

This parameters allows you to enable the verbosity of the SDK to get a variety of runtime information in the console. When developing an application, enabling verbose mode can help you understand the current SDK behavior.
However, this might not be desirable in a shipped version.
default : false

The verbose messages can also be exported into a log file. See sdk_verbose_log_file for more.
String sdk_verbose_log_file

When sdk_verbose is enabled, this parameter allows you to redirect both the SDK verbose messages and your own application messages to a file.
default : (empty) Should contain the path to the file to be written. A file will be created if missing.

Setting this parameter to any value will redirect all std::cout calls of the entire program. This means that your own std::cout calls will be redirected to the log file.
This parameter can be particularly useful for creating a log system, and with Unreal or Unity applications that don't provide a standard console output.
The log file won't be clear after successive executions of the application. This means that it can grow indefinitely if not cleared.
CUcontext sdk_cuda_ctx

If your application uses another CUDA-capable library, giving its CUDA context to the SDK can be useful when sharing GPU memories.
This parameter allows you to set the CUDA context to be used by the SDK.
Leaving this parameter empty asks the SDK to create its own context.
default : (empty)

When creating you own CUDA context, you have to define the device you will use. Do not forget to also specify it on sdk_gpu_id.
On Jetson, you have to set the flag CU_CTX_SCHED_YIELD, during CUDA context creation.
You can also let the SDK create its own context, and use Camera::getCUDAContext() to use it.
InputType input

The SDK can handle different input types:

  • Select a camera by its ID (/dev/videoX on Linux, and 0 to N cameras connected on Windows)
  • Select a camera by its serial number
  • Open a recorded sequence in the SVO file format This parameter allows you to select to desired input. It should be used like this:
InitParameters init_params; // Set initial parameters
init_params.sdk_verbose = True; // Enable verbose mode
init_params.input.setFromCameraID(0); // Selects the camera with ID = 0
InitParameters init_params; // Set initial parameters
init_params.sdk_verbose = True; // Enable verbose mode
init_params.input.setFromSerialNumber(1010); // Selects the camera with serial number = 1010
InitParameters init_params; // Set initial parameters
init_params.sdk_verbose = True; // Enable verbose mode
init_params.input.setFromSVOFile("/path/to/file.svo"); // Selects the and SVO file to be read

Available cameras and their ID/serial can be listed using Camera::getDeviceList.
Each Camera will create its own memory (CPU and GPU), therefore the number of ZED used at the same time can be limited by the configuration of your computer. (GPU/CPU memory and capabilities)
default : (empty)
See InputType for complementary information.

String optional_settings_path

Set the optional path where the SDK has to search for the settings files (SN<XXXX>.conf files). Those file contains the calibration of the camera.
default : (empty). The SNXXX.conf file will be searched in the default directory (/usr/local/zed/settings/ for Linux or C:/ProgramData/stereolabs/settings for Windows)

if a path is specified and no files has been found, the SDK will search on the default path (see default) for the *.conf file.
Automatic download of conf file (through ZED Explorer or the installer) will still download the files on the default path. If you want to use another path by using this entry, make sure to copy the file in the proper location.
InitParameters init_params; // Set initial parameters
std::string home=getenv("HOME"); //get /home/user as string using getenv()
std::string path= home+"/Documents/settings/"; //assuming /home/<user>/Documents/settings/SNXXXX.conf exists. Otherwise, it will be searched in /usr/local/zed/settings/
init_params.optional_settings_path =sl::String(path.c_str());