ZED SDK

https://github.com/stereolabs/zed-sdk
Admin
The ZED SDK is a cross-platform spatial perception library designed to enable real-time depth...
Tokens:117,380
Snippets:945
Trust Score:8.3
License:MIT
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Example commands for all modes

Source: https://github.com/stereolabs/zed-sdk/blob/master/recording/export/svo/python/README.md

These examples show how to run the script for each mode. Modes 0 and 1 require --output_avi_file, while modes 2, 3, and 4 require --output_path_dir. Replace the placeholders with actual file paths.

```bash
python export_svo.py --mode 0 --input_svo_file <input_svo_file> --output_avi_file <output_avi_file>
```

```bash
python export_svo.py --mode 1 --input_svo_file <input_svo_file> --output_avi_file <output_avi_file>
```

```bash
python export_svo.py --mode 2 --input_svo_file <input_svo_file> --output_path_dir <output_path_dir>
```

```bash
python export_svo.py --mode 3 --input_svo_file <input_svo_file> --output_path_dir <output_path_dir>
```

```bash
python export_svo.py --mode 4 --input_svo_file <input_svo_file> --output_path_dir <output_path_dir>
```

--------------------------------

### Run the streaming sender for basic setup

Source: https://github.com/stereolabs/zed-sdk/blob/master/camera streaming/multi_sender/python/README.md

Run the streaming sender sample in the first terminal to set up a basic streaming setup. The port displayed will be used by the receiver.

```bash
python streaming_senders.py
```

--------------------------------

### Example C++ SVO recording command

Source: https://github.com/stereolabs/zed-sdk/blob/master/zed one/svo_recording/README.md

Example command for the C++ sample, recording to my_recording.svo2.

```bash
./ZED_One_SVO_Recording my_recording.svo2
```

--------------------------------

### Example Python SVO recording command

Source: https://github.com/stereolabs/zed-sdk/blob/master/zed one/svo_recording/README.md

Example command for the Python sample, recording to my_recording.svo2.

```bash
python svo_recording.py --output_svo_file my_recording.svo2
```

--------------------------------

### Setup: Install ZED SDK, YOLO dependencies, and CUDA-specific CuPy packages

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/custom detector/python/pytorch_yolo_cupy/README.md

Install the ZED SDK and Python API, then install YOLO dependencies with pip. For GPU acceleration, install the appropriate CuPy package for your CUDA version (cupy-cuda11x for CUDA 11.x, cupy-cuda12x for CUDA 12.x) and cuda-python.

```bash
# Install ZED SDK and Python API
# Download from: https://www.stereolabs.com/developers/release/

# Install YOLO dependencies
pip install ultralytics

# GPU acceleration of data processing and visualization
pip install cupy-cuda11x  # For CUDA 11.x
pip install cupy-cuda12x  # For CUDA 12.x
pip install cuda-python
```

--------------------------------

### Run camera control sample

Source: https://github.com/stereolabs/zed-sdk/blob/master/camera control/python/README.md

Run the camera control sample from the terminal. Requires the ZED SDK and pyZED package installed.

```bash
python camera_control.py 
```

--------------------------------

### Run HTTP server with Python

Source: https://github.com/stereolabs/zed-sdk/blob/master/global localization/map server/README.md

Start a simple HTTP server to serve the map files. The map will be available at http://localhost:8000/.

```bash
python -m http.server 8000
```

```bash
python3 -m http.server 8000
```

--------------------------------

### Setup fusion

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 9 - global localization/python/README.md

Initializes the Fusion module, enables positional tracking, and subscribes to the camera using its serial number.

```APIDOC
## Setup fusion

### Description
Initializes the Fusion module, enables positional tracking, and subscribes to the camera using its serial number.

### Method
N/A

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# step 2
# init the fusion module that will input both the camera and the GPS
fusion = sl.Fusion()
init_fusion_parameters = sl.InitFusionParameters()
init_fusion_parameters.coordinate_system = sl.COORDINATE_SYSTEM.RIGHT_HANDED_Y_UP
init_fusion_parameters.coordinate_units = sl.UNIT.METER

fusion.init(init_fusion_parameters)
fusion.enable_positionnal_tracking()

uuid = sl.CameraIdentifier(camera_info.serial_number)
print("Subscribing to", uuid.serial_number, communication_parameters.comm_type) #Subscribe fusion to camera
status = fusion.subscribe(uuid, communication_parameters, sl.Transform(0,0,0))
if status != sl.FUSION_ERROR_CODE.SUCCESS:
    print("Failed to subscribe to", uuid.serial_number, status)
    exit(1)
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Install ZED SDK and YOLO dependencies

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/custom detector/python/pytorch_yolo_async/README.md

Install the ZED SDK and Python API, then install the ultralytics package for YOLO support. Optionally install cupy-cuda11x or cupy-cuda12x and cuda-python for GPU acceleration of data processing and visualization.

```bash
# Install ZED SDK and Python API
# Download from: https://www.stereolabs.com/developers/release/

# Install YOLO dependencies
pip install ultralytics

# Optional: GPU acceleration of data processing and visualization
pip install cupy-cuda11x  # For CUDA 11.x
pip install cupy-cuda12x  # For CUDA 12.x
pip install cuda-python
```

--------------------------------

### Run Python SVO Playback

Source: https://github.com/stereolabs/zed-sdk/blob/master/zed one/svo_playback/README.md

Command to run the Python example. Requires the script 'svo_playback.py' and an SVO file path as an argument.

```bash
python svo_playback.py --input_svo_file <path_to_svo_file>
```

--------------------------------

### Install YOLOv5 Dependencies

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/custom detector/cpp/tensorrt_yolov5-v6-v8_onnx/README.md

Clone the YOLOv5 repository and install required packages.

```bash
git clone https://github.com/ultralytics/yolov5
cd yolov5
pip install -r requirements.txt
```

--------------------------------

### Example Python receiver command

Source: https://github.com/stereolabs/zed-sdk/blob/master/zed one/streaming_receiver/README.md

Example command to run the Python receiver with a specific IP address and port.

```bash
python streaming_receiver.py --ip_address 192.168.1.100:30000
```

--------------------------------

### Install Ultralytics

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/custom detector/cpp/tensorrt_yolov5-v6-v8_onnx_async/README.md

Install the Ultralytics package to export YOLOv8 models to ONNX format.

```bash
python -m pip install ultralytics
```

--------------------------------

### Install dependencies for Sensors API sample

Source: https://github.com/stereolabs/zed-sdk/blob/master/sensors_api/managed/python/README.md

Install required Python packages for the Sensors API sample. The optional PyOpenGL packages are needed only for the 3D point cloud viewer.

```bash
pip install opencv-python numpy

# Optional, for 3D point cloud viewer:
pip install PyOpenGL PyOpenGL_accelerate
```

--------------------------------

### Example C++ receiver command

Source: https://github.com/stereolabs/zed-sdk/blob/master/zed one/streaming_receiver/README.md

Example command to run the C++ receiver with a specific IP address and port.

```bash
./ZED_One_Streaming_Receiver 192.168.1.100:30000
```

--------------------------------

### Start object detection module

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 6 - object detection/cpp/README.md

Loads the object detection model, which may take a few seconds; first use optimizes for hardware and takes longer. Exits on error.

```cpp
std::cout << "Object Detection: Loading Module..." << std::endl;
zed_error = zed.enableObjectDetection(detection_parameters);
if (zed_error > ERROR_CODE::SUCCESS) {
	std::cout << "Error " << zed_error << ", exit program.\n";
	zed.close();
	return 1;
}
```

--------------------------------

### Enable object detection module

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 8 - body tracking/csharp/README.md

Starts the object detection module, loading the model. The first run may take longer due to hardware optimization.

```C#
Console.WriteLine("Object Detection: Loading Module...");
err = zedCamera.EnableObjectDetection(ref object_detection_parameters);
if (err > ERROR_CODE.SUCCESS)
    Environment.Exit(-1);
```

--------------------------------

### Run C++ SVO Playback

Source: https://github.com/stereolabs/zed-sdk/blob/master/zed one/svo_playback/README.md

Command to run the compiled C++ example. Requires the executable to be built in the 'build' directory and a path to an SVO file.

```bash
cd build
./ZED_One_SVO_Playback <path_to_svo_file>
```

--------------------------------

### CMake configuration for ZED C tutorial 2

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 2 - image capture/c/CMakeLists.txt

Build configuration for the ZED C tutorial 2 example. Sets up CUDA and ZED SDK include/link paths for Windows and Linux, and links the executable against sl_zed_c and CUDA libraries.

```cmake
CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
PROJECT(ZED_C_Tutorial_2)

if(COMMAND cmake_policy)
	cmake_policy(SET CMP0003 OLD)
	cmake_policy(SET CMP0015 OLD)
endif(COMMAND cmake_policy)

SET(EXECUTABLE_OUTPUT_PATH ".")
find_package(CUDA ${ZED_CUDA_VERSION} REQUIRED)
include_directories(${CUDA_INCLUDE_DIRS})
link_directories(${CUDA_LIBRARY_DIRS})

if (WIN32)
include_directories($ENV{ZED_SDK_ROOT_DIR}/include/)
link_directories($ENV{ZED_SDK_ROOT_DIR}/lib/)

else (WIN32)
include_directories("/usr/local/zed/include/")
link_directories("/usr/local/zed/lib/")
endif(WIN32)


ADD_EXECUTABLE(${PROJECT_NAME} main.c)

target_link_libraries(${PROJECT_NAME} sl_zed_c ${CUDA_CUDA_LIBRARY} ${CUDA_CUDART_LIBRARY})
```

--------------------------------

### Enable body tracking module

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 8 - body tracking/python/README.md

Starts the body tracking module, loading the model. The first use may take longer as the model is optimized for the hardware.

```python
err = zed.enable_body_tracking(body_params)
if err > sl.ERROR_CODE.SUCCESS:
    print("Enable Body Tracking : "+repr(err)+". Exit program.")
    zed.close()
    exit()
```

--------------------------------

### Enable body tracking module

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 8 - body tracking/cpp/README.md

Starts the body tracking module, loading the model. This can take a few seconds; the first use optimizes the model for the hardware and takes longer. Exits with EXIT_FAILURE on error.

```cpp
cout << "Body Tracking: Loading Module..." << endl;
returned_state = zed.enableBodyTracking(detection_parameters);
if (returned_state > ERROR_CODE::SUCCESS) {
	cout << "Error " << returned_state << ", exit program.\n";
	zed.close();
	return EXIT_FAILURE;
}
```

--------------------------------

### ZED_SVO_Export usage and examples

Source: https://github.com/stereolabs/zed-sdk/blob/master/recording/export/svo/cpp/README.md

Usage text and command-line examples for the ZED_SVO_Export tool, showing the three parameters (input SVO, output AVI/folder, export mode) and five export modes for AVI or image sequences.

```text
Usage:

ZED_SVO_Export A B C

Please use the following parameters from the command line:
 A - SVO file path (input) : "path/to/file.svo"
 B - AVI file path (output) or image sequence folder(output) : "path/to/output/file.avi" or "path/to/output/folder/"
 C - Export mode:  0=Export LEFT+RIGHT AVI.
                   1=Export LEFT+DEPTH_VIEW AVI.
                   2=Export LEFT+RIGHT image sequence.
                   3=Export LEFT+DEPTH_VIEW image sequence.
                   4=Export LEFT+DEPTH_16Bit image sequence.
 A and B need to end with '/' or '\'

Examples:
  (AVI LEFT+RIGHT)              ZED_SVO_Export "path/to/file.svo" "path/to/output/file.avi" 0
  (AVI LEFT+DEPTH)              ZED_SVO_Export "path/to/file.svo" "path/to/output/file.avi" 1
  (SEQUENCE LEFT+RIGHT)         ZED_SVO_Export "path/to/file.svo" "path/to/output/folder/" 2
  (SEQUENCE LEFT+DEPTH)         ZED_SVO_Export "path/to/file.svo" "path/to/output/folder/" 3
  (SEQUENCE LEFT+DEPTH_16Bit)   ZED_SVO_Export "path/to/file.svo" "path/to/output/folder/" 4
```

--------------------------------

### CMake configuration for Spatial Mapping C# example

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 5 - spatial mapping/csharp/CMakeLists.txt

Configures the CMake build for the Spatial Mapping C# example. It sets the project name to 'Spatial_Mapping', includes the required source files, forces the x64 platform (ZED SDK does not support 32-bit), targets .NET Framework 4.6.1, sets the C# language version to 7, adds required .NET references, and includes the Stereolabs ZED SDK NuGet package.

```cmake
cmake_minimum_required( VERSION 3.8.0 )

project(Spatial_Mapping CSharp)

add_executable(${PROJECT_NAME}
	Program.cs
	App.config
	packages.config
	Properties/AssemblyInfo.cs
)

# Set the target platform to x64, since ZED SDK does not support 32-bits arch
target_compile_options(${PROJECT_NAME} PRIVATE "/platform:x64" )

# Set the .NET Framework version for the target.
set_property(TARGET ${PROJECT_NAME} PROPERTY VS_DOTNET_TARGET_FRAMEWORK_VERSION "v4.6.1")

# Set the C# language version, otherwise default 3.0 is taken
set(CMAKE_CSharp_FLAGS "/langversion:7")

set_property(TARGET ${PROJECT_NAME} PROPERTY VS_DOTNET_REFERENCES
        "Microsoft.CSharp"
        "PresentationCore"
        "PresentationFramework"
        "System"
        "System.Numerics"
)

set(CMAKE_SUPPRESS_REGENERATION true)
set_property(TARGET ${PROJECT_NAME} PROPERTY VS_PACKAGE_REFERENCES 
	"Stereolabs.zed_5.*"
)
```

--------------------------------

### Run the program: python svo_recording.py

Source: https://github.com/stereolabs/zed-sdk/blob/master/recording/recording/multi camera/python/README.md

Use this command in your terminal to start the multi-camera SVO recording sample. The program opens all connected cameras and records until you press 'ctrl+c' to stop file creation.

```bash
python svo_recording.py 
```

--------------------------------

### Create a camera

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 9 - global localization/python/README.md

Creates and opens a ZED camera, starts publishing its data, and enables positional tracking with IMU fusion.

```APIDOC
## Create a camera

### Description
Creates and opens a ZED camera, starts publishing its data, and enables positional tracking with IMU fusion.

### Method
N/A

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
# step 1
# create the camera that will input the position from its odometry
zed = sl.Camera()
status = zed.open(init_params)
if status > sl.ERROR_CODE.SUCCESS:
    print("Camera Open: " + repr(status) + ". Exit program.")
    exit()

# set up communication parameters and start publishing
communication_parameters = sl.CommunicationParameters()
communication_parameters.set_for_shared_memory()
zed.start_publishing(communication_parameters)

# warmup for camera 
if zed.grab() > sl.ERROR_CODE.SUCCESS:
    print("Camera grab: " + repr(status) + ". Exit program.")
    exit()
else:
    zed.get_position(odometry_pose, sl.REFERENCE_FRAME.WORLD)

tracking_params = sl.PositionalTrackingParameters()
# These parameters are mandatory to initialize the transformation between GNSS and ZED reference frames.
tracking_params.enable_imu_fusion = True
tracking_params.set_gravity_as_origin = True
err = zed.enable_positional_tracking(tracking_params)
if (err > sl.ERROR_CODE.SUCCESS):
    print("Camera positional tracking: " + repr(status) + ". Exit program.")
    exit()
camera_info = zed.get_camera_information()
```

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Run the streaming sender

Source: https://github.com/stereolabs/zed-sdk/blob/master/camera streaming/multi_sender/python/README.md

Run the streaming sender sample with Python. This command starts the program that opens all plugged cameras and broadcasts their images.

```bash
python streaming_sender.py
```

--------------------------------

### Usage and options for positional_tracking.py

Source: https://github.com/stereolabs/zed-sdk/blob/master/positional tracking/positional tracking/python/README.md

Shows the command-line usage and options for the positional tracking sample. Includes examples for map creation and SVO playback with an area file.

```text
Usage: python3 positional_tracking.py [options]

Options:
  --help                      Shows usage information.
  --resolution <mode>         Optional. Resolution options: (HD2K | HD1200 | HD1080 | HD720 | SVGA | VGA)
  --svo <filename.svo>        Optional. Use SVO file input. Mutually exclusive with --stream.
  --stream <ip[:port]>        Optional. Use network streaming input. Mutually exclusive with --svo.
  -i <input_area_file>        Optional. Input area file used in explore mode (default) or --map mode
  --map -o <output_area_file> Optional. Map mode creates or updates an .area file.
                                        Requires -o <output_area_filename> for generated map
  --roi <roi_filepath>        Optional. Region of interest image mask to ignore a static area
  --custom-initial-pose       Optional. Use custom initial pose (see code comments for more detail)
  --2d-ground-mode            Optional. Enable 2D ground mode
  --export-tum                Optional. Export camera trajectory to out.tum file in TUM format

Examples:
  ./build/ZED_Positional_Tracking --map -o new_map.area
  ./build/ZED_Positional_Tracking --svo recording.svo2 -i map.area
```

--------------------------------

### Run the YOLOv8-seg ONNX sample

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/custom detector/cpp/tensorrt_yolov8_seg_onnx/README.md

Run the sample with a TensorRT engine file. The first argument is the engine file, and the second optional argument is the ZED camera ID or an SVO filepath. Examples show using a ZED camera (auto-detect) or an SVO file.

```bash
./yolov8_seg_onnx_zed [.engine] [zed camera id / optional svo filepath]

# Examples:
./yolov8_seg_onnx_zed yolov8s-seg.engine           # ZED camera (auto-detect)
./yolov8_seg_onnx_zed yolov8s-seg.engine ./foo.svo # SVO file
```

--------------------------------

### Start object detection module

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 6 - object detection/python/README.md

Enables the object detection module, which loads and optimizes the model on first use. Exits if enabling fails.

```python
err = zed.enable_object_detection(obj_param)
if err > sl.ERROR_CODE.SUCCESS :
    print (repr(err))
    zed.close()
    exit(1)
```

--------------------------------

### Run the sample with the engine generated

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/custom detector/cpp/onnx_yolo_internal/README.md

Command-line usage for the yolo_onnx_zed sample. The first argument is the ONNX model file, the second is the ZED camera ID or an optional SVO filepath. Examples show running with yolo26m.onnx on camera 0 and with an SVO file.

```sh
./yolo_onnx_zed [.onnx] [zed camera id / optional svo filepath]

# For example yolo26m
./yolo_onnx_zed yolo26m.onnx 0      # 0  for zed camera id 0

# With an SVO file
./yolo_onnx_zed yolo26m.onnx ./foo.svo
```

--------------------------------

### CMake configuration for ZED SVO Export C# example

Source: https://github.com/stereolabs/zed-sdk/blob/master/recording/export/svo/csharp/CMakeLists.txt

Sets up the C# executable with x64 platform, .NET Framework 4.6.1, C# 7 language version, and required references including Stereolabs.zed_5.* and OpenCvSharp4.Windows.

```cmake
cmake_minimum_required( VERSION 3.8.0 )

project(ZED_SVO_Export CSharp)

add_executable(${PROJECT_NAME}
	Program.cs
	App.config
	packages.config
	Properties/AssemblyInfo.cs
)

# Set the target platform to x64, since ZED SDK does not support 32-bits arch
target_compile_options(${PROJECT_NAME} PRIVATE "/platform:x64" )

# Set the .NET Framework version for the target.
set_property(TARGET ${PROJECT_NAME} PROPERTY VS_DOTNET_TARGET_FRAMEWORK_VERSION "v4.6.1")

# Set the C# language version, otherwise default 3.0 is taken
set(CMAKE_CSharp_FLAGS "/langversion:7")

set_property(TARGET ${PROJECT_NAME} PROPERTY VS_DOTNET_REFERENCES
	"Microsoft.CSharp"
	"PresentationCore"
	"PresentationFramework"
	"System"
	"System.Numerics"
	"WindowsBase"
)

set(CMAKE_SUPPRESS_REGENERATION true)

set_property(TARGET ${PROJECT_NAME} PROPERTY VS_PACKAGE_REFERENCES
	"Stereolabs.zed_5.*"
	"OpenCvSharp4.Windows_4.5.0.20201013"
)
```

--------------------------------

### Setup Fusion module and subscribe to camera

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 9 - global localization/python/README.md

Initializes the Fusion module with a right-handed Y-up coordinate system in meters, enables positional tracking, and subscribes to the camera using its serial number and the shared memory communication parameters. Exits if subscription fails.

```python
    # step 2
    # init the fusion module that will input both the camera and the GPS
    fusion = sl.Fusion()
    init_fusion_parameters = sl.InitFusionParameters()
    init_fusion_parameters.coordinate_system = sl.COORDINATE_SYSTEM.RIGHT_HANDED_Y_UP
    init_fusion_parameters.coordinate_units = sl.UNIT.METER

    fusion.init(init_fusion_parameters)
    fusion.enable_positionnal_tracking()
    
    uuid = sl.CameraIdentifier(camera_info.serial_number)
    print("Subscribing to", uuid.serial_number, communication_parameters.comm_type) #Subscribe fusion to camera
    status = fusion.subscribe(uuid, communication_parameters, sl.Transform(0,0,0))
    if status != sl.FUSION_ERROR_CODE.SUCCESS:
        print("Failed to subscribe to", uuid.serial_number, status)
        exit(1)

```

--------------------------------

### Sensor Placer Command-Line Usage Examples

Source: https://github.com/stereolabs/zed-sdk/blob/master/sensors_api/sensor_placer/cpp/README.md

Shows common invocations: auto-detect sensors, load an existing config, and specify an output file. The -o flag default is <input>_placed.json.

```bash
# Auto-detect all connected sensors
./SensorPlacer --auto

# Load an existing configuration
./SensorPlacer sensors_config.json

# Specify an output file (auto-saved on close)
./SensorPlacer sensors_config.json -o sensors_placed.json
```

--------------------------------

### Run hello_zed_gpu.py on GeForce RTX 4060 Ti with ZED2

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 1 - hello ZED/python/README.md

Another example of running the same script, showing output with CuPy version 13.4.1, CUDA version 11080, and GPU processing results.

```bash
> python hello_zed_gpu.py
✅ CuPy detected - GPU acceleration available
   CuPy version: 13.4.1
   CUDA version: 11080
ZED SDK CuPy Integration Test
========================================
Opening ZED camera...
[2025-07-30 15:38:50 UTC][ZED][INFO] Logging level INFO
[2025-07-30 15:38:51 UTC][ZED][INFO] Using USB input... Switched to default resolution HD720
[2025-07-30 15:38:52 UTC][ZED][INFO] [Init]  Camera successfully opened.
[2025-07-30 15:38:52 UTC][ZED][INFO] [Init]  Camera FW version: 1523
[2025-07-30 15:38:52 UTC][ZED][INFO] [Init]  Video mode: HD720@30
[2025-07-30 15:38:52 UTC][ZED][INFO] [Init]  Serial Number: S/N 24046162
[2025-07-30 15:38:52 UTC][ZED][INFO] [Init]  Depth mode: NEURAL
ZED camera opened successfully.
Retrieving image data...
Retrieved image on GPU: 1280x720

🧪 Testing GPU image processing (basic grayscale conversion)...
   Input image: (720, 1280, 4)
   Processed image: (720, 1280)
✅ GPU processing test passed!
========================================

💾 Testing memory allocation strategies...
   CPU allocation: (480, 640, 4), float32
   GPU allocation: (480, 640, 4), float32
   CPU->GPU transfer: (480, 640, 4)
   GPU->CPU transfer: (480, 640, 4)
✅ Memory allocation test passed!
========================================

🔍 Testing GPU memory usage...
   Initial GPU memory usage: 0.0 MB
   After allocation: 15.3 MB
   After cleanup: 0.0 MB
✅ GPU memory test passed!
========================================

🔬 Testing data integrity...
   Data integrity verified: (2, 2, 4)
✅ Data integrity test passed!
========================================

⚡ Running performance benchmark...
   Benchmark image size: 1280x720
   CPU processing (10 iterations): 97.423 milliseconds
   GPU processing (10 iterations): 1.970 milliseconds
   Speedup: 49.4x
🚀 GPU processing is faster!
========================================

🎉 All tests completed!
   Your system is ready for GPU-accelerated ZED processing with the Python API!
```

--------------------------------

### Install CuPy and CUDA Python bindings for GPU acceleration

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/custom detector/python/onnx_yolo_internal/README.md

Install CuPy for GPU acceleration and CUDA Python bindings. Choose the CuPy package that matches your CUDA version (11.x or 12.x). This setup is optional but recommended for improved data retrieval and handling on GPU.

```bash
pip install cupy-cuda11x  # For CUDA 11.x
pip install cupy-cuda12x  # For CUDA 12.x

# Install CUDA Python bindings
pip install cuda-python
```

--------------------------------

### Run the Sample

Source: https://github.com/stereolabs/zed-sdk/blob/master/depth sensing/voxel point cloud/cpp/README.md

Runs the compiled sample with different input sources: live camera (no argument), SVO file (path), or IP stream (address:port).

```bash
./ZED_Voxel_Point_Cloud             # Live camera
./ZED_Voxel_Point_Cloud path.svo    # SVO file
./ZED_Voxel_Point_Cloud 192.168.1.10:30000  # Stream
```

--------------------------------

### Run with optional arguments

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/birds eye viewer/python/README.md

Run the sample with optional arguments: --input_svo_file for playback, --ip_address to connect to a camera, --resolution (HD2K, HD1200, HD1080, HD720, SVGA, VGA), --disable_gui to improve performance, and --enable_batching_reid to enable batching re-identification.

```bash
python object_detection_birds_view.py --input_svo_file <input_svo_file> --ip_address <ip_address> --resolution <resolution> --disable_gui --enable_batching_reid    
```

--------------------------------

### Configure CMake build for ZED Path export FBX example

Source: https://github.com/stereolabs/zed-sdk/blob/master/positional tracking/export/fbx/cpp/CMakeLists.txt

CMake configuration for building the ZED Path export FBX example. It requires ZED SDK and CUDA, and optionally links against the FBX SDK. The FBX_DIR variable must be adjusted to the local FBX installation path. If LINK_SHARED_ZED is OFF on Windows, the build fails with a fatal error.

```cmake
CMAKE_MINIMUM_REQUIRED(VERSION 3.5)

PROJECT(ZED_Path_export_FBX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
SET(CMAKE_BUILD_TYPE "Release")

option(LINK_SHARED_ZED "Link with the ZED SDK shared executable" ON)

if (NOT LINK_SHARED_ZED AND MSVC)
    message(FATAL_ERROR "LINK_SHARED_ZED OFF : ZED SDK static libraries not available on Windows")
endif()

find_package(ZED REQUIRED)
find_package(CUDA ${ZED_CUDA_VERSION} REQUIRED)

# change this according to your FBX install directory
if(WIN32)
	set(FBX_DIR "C:/Program Files/Autodesk/FBX/FBX SDK/2020.3.1")
else()
	set(FBX_DIR "/usr/local/lib/FBX")
endif()

if(EXISTS FBX_DIR)
	include("${FBX_DIR}/samples/CMakeSettings.txt")
	include_directories("${FBX_ROOT}/include")
	set(FBX_COMMON_DIR "${FBX_CMAKE_ROOT}/Common")
	include_directories("${FBX_COMMON_DIR}")
	set(FBX_SRC ${FBX_COMMON_DIR}/Common.cxx)
	add_definitions(-DFBX_EXPORT)
else()
	message(AUTHOR_WARNING "FBX library not found")
endif()

include_directories(${CUDA_INCLUDE_DIRS})
include_directories(${ZED_INCLUDE_DIRS})
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)

link_directories(${ZED_LIBRARY_DIR})
link_directories(${CUDA_LIBRARY_DIRS})

ADD_EXECUTABLE(${PROJECT_NAME} include/utils.hpp src/main.cpp ${FBX_SRC})

if (LINK_SHARED_ZED)
	SET(ZED_LIBS ${ZED_LIBRARIES} ${CUDA_CUDA_LIBRARY} ${CUDA_CUDART_LIBRARY})
else()
	SET(ZED_LIBS ${ZED_STATIC_LIBRARIES} ${CUDA_CUDA_LIBRARY} ${CUDA_LIBRARY})
endif()

TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${ZED_LIBS} ${FBXSDK_LIBRARY} ${FBX_REQUIRED_LIBS_DEPENDENCY})
```

--------------------------------

### Run object detection image viewer with arguments

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/image viewer/python/README.md

Runs the sample with optional arguments: --input_svo_file for playback of an .svo file, --ip_address to connect to a camera at an IP address (format a.b.c.d:port or a.b.c.d), and --resolution to set one of HD2K, HD1200, HD1080, HD720, SVGA, or VGA.

```bash
python object_detection_image_viewer.py --input_svo_file <input_svo_file> --ip_address <ip_address> --resolution <resolution>
```

--------------------------------

### Run the sample

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/custom detector/cpp/tensorrt_yolov5-v6-v8_onnx_async/README.md

Run the detector with a TensorRT engine and either a ZED camera ID or an SVO file path.

```bash
./yolo_onnx_zed [.engine] [zed camera id / optional svo filepath]
```

```bash
# Examples:
./yolo_onnx_zed yolov8n.engine 0           # ZED camera ID 0
./yolo_onnx_zed yolov8n.engine ./foo.svo   # SVO file
```

--------------------------------

### CMakeLists.txt for ZED Object Detection Image Viewer

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/image viewer/cpp/CMakeLists.txt

CMake configuration for the ZED object detection image viewer sample. Requires ZED SDK, CUDA, GLUT, GLEW, and OpenGL. The LINK_SHARED_ZED option defaults to ON; setting it OFF on Windows triggers a fatal error because static ZED libraries are unavailable. Builds an executable from sources in src/ and headers in include/, linking against ZED, CUDA, OpenGL, GLUT, and GLEW libraries. If INSTALL_SAMPLES is set, the target is appended to SAMPLE_LIST for installation.

```cmake
cmake_minimum_required(VERSION 3.5)
PROJECT(ZED_Object_detection_image_viewer)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
SET(CMAKE_BUILD_TYPE "Release")

option(LINK_SHARED_ZED "Link with the ZED SDK shared executable" ON)

if (NOT LINK_SHARED_ZED AND MSVC)
    message(FATAL_ERROR "LINK_SHARED_ZED OFF : ZED SDK static libraries not available on Windows")
endif()

find_package(ZED REQUIRED)
find_package(CUDA ${ZED_CUDA_VERSION} REQUIRED)
find_package(GLUT REQUIRED)
find_package(GLEW REQUIRED)
SET(OpenGL_GL_PREFERENCE GLVND)
find_package(OpenGL REQUIRED)

include_directories(${ZED_INCLUDE_DIRS})
include_directories(${GLEW_INCLUDE_DIRS})
include_directories(${GLUT_INCLUDE_DIR})
include_directories(${CUDA_INCLUDE_DIRS})
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)

link_directories(${ZED_LIBRARY_DIR})
link_directories(${GLEW_LIBRARY_DIRS})
link_directories(${GLUT_LIBRARY_DIRS})
link_directories(${OpenGL_LIBRARY_DIRS})
link_directories(${CUDA_LIBRARY_DIRS})

FILE(GLOB_RECURSE SRC_FILES src/*.c*)
FILE(GLOB_RECURSE HDR_FILES include/*.h*)

add_executable(${PROJECT_NAME} ${HDR_FILES} ${SRC_FILES})

if (LINK_SHARED_ZED)
    SET(ZED_LIBS ${ZED_LIBRARIES} ${CUDA_CUDA_LIBRARY} ${CUDA_CUDART_LIBRARY})
else()
    SET(ZED_LIBS ${ZED_STATIC_LIBRARIES} ${CUDA_CUDA_LIBRARY} ${CUDA_LIBRARY})
endif()

target_link_libraries(${PROJECT_NAME}
                        ${ZED_LIBS}
                        ${OPENGL_LIBRARIES}
                        ${GLUT_LIBRARIES}
                        ${GLEW_LIBRARIES})

if(INSTALL_SAMPLES)
    LIST(APPEND SAMPLE_LIST ${PROJECT_NAME})
    SET(SAMPLE_LIST "${SAMPLE_LIST}" PARENT_SCOPE)
endif()
```

--------------------------------

### Use JSON Configuration

Source: https://github.com/stereolabs/zed-sdk/blob/master/sensors_api/threaded/cpp/README.md

Run the sample using a JSON configuration file.

```bash
./SensorsAPISample sensors_config.json
```

--------------------------------

### Install pyopengl dependency

Source: https://github.com/stereolabs/zed-sdk/blob/master/body tracking/body tracking/python/README.md

Install the required Python OpenGL package using pip.

```bash
python3 -m pip install pyopengl
```

--------------------------------

### CMakeLists.txt for ZED SVO Playback sample

Source: https://github.com/stereolabs/zed-sdk/blob/master/recording/playback/external_data/cpp/CMakeLists.txt

CMake configuration for the ZED SVO Playback sample. Requires CMake 3.5+, C++17, and the ZED SDK, OpenCV, and CUDA packages. The LINK_SHARED_ZED option controls whether to link against shared or static ZED libraries; static linking is not supported on Windows and triggers a fatal error. The executable is built from include/utils.hpp and src/main.cpp, and if INSTALL_SAMPLES is set, the project is appended to SAMPLE_LIST for installation.

```cmake
CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
PROJECT(ZED_SVO_Playback)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
SET(CMAKE_BUILD_TYPE "RelWithDebInfo")

option(LINK_SHARED_ZED "Link with the ZED SDK shared executable" ON)

if (NOT LINK_SHARED_ZED AND MSVC)
    message(FATAL_ERROR "LINK_SHARED_ZED OFF : ZED SDK static libraries not available on Windows")
endif()

find_package(ZED REQUIRED)
find_package(OpenCV REQUIRED)
find_package(CUDA ${ZED_CUDA_VERSION} REQUIRED)

include_directories(${CUDA_INCLUDE_DIRS})
include_directories(${ZED_INCLUDE_DIRS})
include_directories(${OpenCV_INCLUDE_DIRS})
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)

link_directories(${ZED_LIBRARY_DIR})
link_directories(${CUDA_LIBRARY_DIRS})
link_directories(${OpenCV_LIBRARY_DIRS})

ADD_EXECUTABLE(${PROJECT_NAME} include/utils.hpp src/main.cpp)

if (LINK_SHARED_ZED)
    SET(ZED_LIBS ${ZED_LIBRARIES} ${CUDA_CUDA_LIBRARY} ${CUDA_CUDART_LIBRARY})
else()
    SET(ZED_LIBS ${ZED_STATIC_LIBRARIES} ${CUDA_CUDA_LIBRARY} ${CUDA_LIBRARY})
endif()

TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${ZED_LIBS} ${OpenCV_LIBRARIES})

if(INSTALL_SAMPLES)
    LIST(APPEND SAMPLE_LIST ${PROJECT_NAME})
    SET(SAMPLE_LIST "${SAMPLE_LIST}" PARENT_SCOPE)
endif()
```

--------------------------------

### Install YOLOv6 Dependencies

Source: https://github.com/stereolabs/zed-sdk/blob/master/object detection/custom detector/cpp/tensorrt_yolov5-v6-v8_onnx/README.md

Clone the YOLOv6 repository and install required packages for ONNX export.

```bash
git clone https://github.com/meituan/YOLOv6
cd YOLOv6
pip install -r requirements.txt
pip install onnx>=1.10.0
```

--------------------------------

### Run body_tracking.py

Source: https://github.com/stereolabs/zed-sdk/blob/master/body tracking/body tracking/python/README.md

Run the body tracking sample with default settings (wired camera).

```bash
python body_tracking.py
```

--------------------------------

### Install cuda-python bindings

Source: https://github.com/stereolabs/zed-sdk/blob/master/depth sensing/depth sensing/python/README.md

Install the CUDA Python bindings required for GPU acceleration with CuPy.

```sh
pip install cuda-python
```

--------------------------------

### Run Python ZED One Live sample

Source: https://github.com/stereolabs/zed-sdk/blob/master/zed one/live/README.md

Run the Python sample script. The script opens the camera, displays live video, and prints camera information.

```bash
python live.py
```

--------------------------------

### CMakeLists.txt for ZED Manual Sensing ROI sample

Source: https://github.com/stereolabs/zed-sdk/blob/master/depth sensing/manual region of interest/cpp/CMakeLists.txt

CMake configuration for the ZED Manual Sensing ROI sample. Requires CMake 3.5+, C++17, and the ZED SDK, OpenCV, and CUDA packages. The LINK_SHARED_ZED option controls whether to link against shared or static ZED libraries; static linking is not supported on Windows and triggers a fatal error. The executable is built from src/main.cpp and linked with ZED, CUDA, and OpenCV libraries. If INSTALL_SAMPLES is set, the project is appended to SAMPLE_LIST for installation.

```cmake
CMAKE_MINIMUM_REQUIRED(VERSION 3.5)
PROJECT(ZED_Manual_Sensing_ROI)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
SET(CMAKE_BUILD_TYPE "Release")

option(LINK_SHARED_ZED "Link with the ZED SDK shared executable" ON)

if (NOT LINK_SHARED_ZED AND MSVC)
    message(FATAL_ERROR "LINK_SHARED_ZED OFF : ZED SDK static libraries not available on Windows")
endif()

find_package(ZED REQUIRED)
find_package(OpenCV REQUIRED)
find_package(CUDA ${ZED_CUDA_VERSION} REQUIRED)

include_directories(${CUDA_INCLUDE_DIRS})
include_directories(${ZED_INCLUDE_DIRS})
include_directories(${OpenCV_INCLUDE_DIRS})

link_directories(${ZED_LIBRARY_DIR})
link_directories(${OpenCV_LIBRARY_DIRS})
link_directories(${CUDA_LIBRARY_DIRS})

ADD_EXECUTABLE(${PROJECT_NAME} src/main.cpp)

if (LINK_SHARED_ZED)
    SET(ZED_LIBS ${ZED_LIBRARIES} ${CUDA_CUDA_LIBRARY} ${CUDA_CUDART_LIBRARY})
else()
    SET(ZED_LIBS ${ZED_STATIC_LIBRARIES} ${CUDA_CUDA_LIBRARY} ${CUDA_LIBRARY})
endif()

TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${ZED_LIBS} ${OpenCV_LIBRARIES})

if(INSTALL_SAMPLES)
    LIST(APPEND SAMPLE_LIST ${PROJECT_NAME})
    SET(SAMPLE_LIST "${SAMPLE_LIST}" PARENT_SCOPE)
endif()
```

--------------------------------

### Run plane detection sample (default)

Source: https://github.com/stereolabs/zed-sdk/blob/master/plane detection/plane detection/python/README.md

Launches the plane detection sample using the default wired camera.

```bash
python plane_detection.py
```

--------------------------------

### Create and open a ZED camera with InitParameters

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 2 - image capture/cpp/README.md

Creates a ZED camera object, sets the resolution to AUTO and framerate to 30 fps, then opens the camera. Exits if the open call returns an error code greater than SUCCESS.

```cpp
// Create a ZED camera object
Camera zed;

// Set configuration parameters
InitParameters init_params;
init_params.camera_resolution = RESOLUTION::AUTO; // Use HD720 opr HD1200 video mode, depending on camera type.
init_params.camera_fps = 30; // Set fps at 30

// Open the camera
ERROR_CODE err = zed.open(init_params);
if (err > ERROR_CODE::SUCCESS)
    exit(-1);
```

--------------------------------

### Create and configure a ZED camera

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 4 - positional tracking/cpp/README.md

Creates a Camera object, sets initialization parameters (resolution, coordinate system, units), and opens the camera. Exits if opening fails.

```c++
// Create a ZED camera object
Camera zed;

// Set configuration parameters
InitParameters init_params;
init_params.camera_resolution = RESOLUTION::AUTO; // Use HD720 or HD1200 video mode (default fps: 60)
init_params.coordinate_system = COORDINATE_SYSTEM::RIGHT_HANDED_Y_UP; // Use a right-handed Y-up coordinate system
init_params.coordinate_units = UNIT::METER; // Set units in meters

// Open the camera
ERROR_CODE err = zed.open(init_params);
if (err > ERROR_CODE::SUCCESS)
    exit(-1);
```

--------------------------------

### Download and run Fast-FoundationStereo model

Source: https://github.com/stereolabs/zed-sdk/blob/master/depth sensing/custom depth/cpp/tensorrt_stereo_onnx/README.md

Downloads the prebuilt Fast-FoundationStereo ONNX export (576x960, 8 iterations) and runs the sample with it. The weights are non-commercial (research-only) and not redistributable.

```bash
python3 get_model.py --model fast-foundation-stereo                 # 576x960, 8 iters
./build/ZED_Custom_Depth_TensorRT models/fast_foundation_stereo_576x960_iter8.onnx
```

--------------------------------

### Install CuPy for CUDA (cupy-cuda11x or cupy-cuda12x)

Source: https://github.com/stereolabs/zed-sdk/blob/master/depth sensing/depth sensing/python/README.md

Install CuPy for GPU-accelerated data retrieval. Choose the variant matching your CUDA version (11.x or 12.x).

```sh
pip install cupy-cuda11x  # For CUDA 11.x
pip install cupy-cuda12x  # For CUDA 12.x
```

--------------------------------

### Streaming sender usage examples

Source: https://github.com/stereolabs/zed-sdk/blob/master/zed one/streaming_sender/README.md

Examples of running the streaming sender: default port, custom port 30001, and Python with HD1080 resolution. Press Ctrl+C to stop streaming.

```bash
# Stream on default port
./ZED_One_Streaming_Sender
```

```bash
# Stream on custom port
./ZED_One_Streaming_Sender 30001
```

```bash
# Python with resolution
python streaming_sender.py --resolution HD1080
```

--------------------------------

### Configure and Open ZED Camera with InitParameters

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 1 - hello ZED/csharp/README.md

Creates a Camera object, sets resolution to HD1080 and FPS to 30, then opens the camera. If the open fails (error code greater than SUCCESS), the program exits with code -1.

```csharp
 InitParameters init_params = new InitParameters();
 init_params.resolution = RESOLUTION.HD1080;
 init_params.cameraFPS = 30;
 Camera zedCamera = new Camera();

 // Open the camera
 ERROR_CODE err = zedCamera.Open(ref init_params);
 if (err > ERROR_CODE.SUCCESS)
	Environment.Exit(-1);
```

--------------------------------

### Configure and open ZED camera with SL_InitParameters

Source: https://github.com/stereolabs/zed-sdk/blob/master/tutorials/tutorial 1 - hello ZED/c/README.md

Create a ZED camera object and set SL_InitParameters before opening the camera. The parameters can only be set before opening and cannot be changed while the camera is in use. Then open the camera with sl_open_camera, checking the returned state for errors.

```c
//Create a ZED camera object
int camera_id = 0;
sl_create_camera(camera_id);

//Set configuration parameters
struct SL_InitParameters init_param;
init_param.camera_fps = 30;
init_param.resolution = SL_RESOLUTION_HD1080;
init_param.input_type = SL_INPUT_TYPE_USB;
init_param.camera_device_id = camera_id;
init_param.camera_image_flip = SL_FLIP_MODE_AUTO;
init_param.camera_disable_self_calib = false;
init_param.enable_image_enhancement = true;
init_param.depth_mode = SL_DEPTH_MODE_NEURAL;
init_param.depth_stabilization = 30;
init_param.depth_maximum_distance = 40;
init_param.depth_minimum_distance = -1;
init_param.coordinate_unit = SL_UNIT_METER;
init_param.coordinate_system = SL_COORDINATE_SYSTEM_LEFT_HANDED_Y_UP;
init_param.sdk_gpu_id = -1;
init_param.sdk_verbose = false;
init_param.sensors_required = false;
init_param.enable_right_side_measure = false;
```

```c
# Open the camera
int state = sl_open_camera(camera_id, &init_param, "", "", "", "", "", "");

  if (state != 0) {
  printf("Error Open \n");
      return 1;
  }
```

--------------------------------

### CMake configuration for ZED SDK samples

Source: https://github.com/stereolabs/zed-sdk/blob/master/CMakeLists.txt

Sets up the build for ZED SDK samples and tutorials. Options INSTALL_SAMPLES and BUILD_CPP control deployment and language selection. Adds subdirectories for each sample, with additional C++-only samples and aarch64-specific ones.

```cmake
cmake_minimum_required(VERSION 3.5)
PROJECT(SamplesAndTutos)

OPTION(INSTALL_SAMPLES "Once build, deploy samples into bin" ON)
OPTION(BUILD_CPP "Build c++ samples else c#" ON)

if(${BUILD_CPP})
    SET(TYPE "cpp")
else()
    SET(TYPE "csharp")
endif()

SET(CMAKE_BUILD_TYPE "Release")

SET(SAMPLE_LIST "")
add_subdirectory("body tracking/body tracking/${TYPE}")
add_subdirectory("camera control/${TYPE}")
add_subdirectory("depth sensing/depth sensing/${TYPE}")
add_subdirectory("depth sensing/voxel point cloud/${TYPE}")
add_subdirectory("object detection/image viewer/${TYPE}")
add_subdirectory("object detection/birds eye viewer/${TYPE}")
add_subdirectory("object detection/concurrent detections/cpp")
add_subdirectory("object detection/multi-camera_multi-model/cpp")
add_subdirectory("plane detection/plane detection/${TYPE}")
add_subdirectory("positional tracking/positional tracking/${TYPE}")
add_subdirectory("spatial mapping/spatial mapping/${TYPE}")
add_subdirectory("recording/export/svo/${TYPE}")
add_subdirectory("recording/playback/single camera/${TYPE}")
add_subdirectory("recording/recording/single camera/${TYPE}")
if(${BUILD_CPP})
    add_subdirectory("recording/export/sensors/${TYPE}")
    add_subdirectory("recording/playback/multi camera/${TYPE}")
    add_subdirectory("recording/recording/multi camera/${TYPE}")
    add_subdirectory("spatial mapping/multi camera/${TYPE}")
    add_subdirectory("plane detection/floor plane/${TYPE}")
    add_subdirectory("global localization/live/${TYPE}")
    add_subdirectory("global localization/playback/${TYPE}")
    add_subdirectory("global localization/recording/${TYPE}")
    add_subdirectory("body tracking/multi-camera/${TYPE}")
    add_subdirectory("body tracking/export/fbx export/${TYPE}")
    add_subdirectory("depth sensing/image refocus/${TYPE}")
    add_subdirectory("depth sensing/automatic region of interest/${TYPE}")
    add_subdirectory("depth sensing/manual region of interest/${TYPE}")
    add_subdirectory("depth sensing/multi camera/${TYPE}")
    add_subdirectory("camera streaming/receiver/${TYPE}")
    add_subdirectory("camera streaming/single_sender/${TYPE}")
    add_subdirectory("camera streaming/multi_sender/${TYPE}")
    add_subdirectory("zed one/live/${TYPE}")
    add_subdirectory("zed one/svo_playback/${TYPE}")
    add_subdirectory("zed one/svo_recording/${TYPE}")
    add_subdirectory("zed one/svo_external_data/${TYPE}")
    add_subdirectory("zed one/streaming_sender/${TYPE}")
    add_subdirectory("zed one/streaming_receiver/${TYPE}")
    if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
        add_subdirectory("zed one/custom_inference/${TYPE}")
    endif()
    add_subdirectory("virtual stereo/${TYPE}")
endif()

add_subdirectory("tutorials")

if(${INSTALL_SAMPLES} AND ${BUILD_CPP})
    INSTALL(TARGETS ${SAMPLE_LIST} RUNTIME DESTINATION ${CMAKE_SOURCE_DIR}/bin)
endif()
```

--------------------------------

### Build Sensor Placer with CMake and Make

Source: https://github.com/stereolabs/zed-sdk/blob/master/sensors_api/sensor_placer/cpp/README.md

Builds the SensorPlacer GUI. Requires ZED SDK 5.2+, CUDA, Qt 5 (Widgets + OpenGL), and OpenGL.

```bash
mkdir build && cd build
cmake ..
make -j$(nproc)
```
Tokens:
Raw