Developer Center

Documentation

Learn how to use the ZED and build your first app with the SDK.

Explore docs

Code Samples

See how easy it is to use the API and its samples.

See samples

Tutorials

Get up and running by building your first tutorial apps.

See tutorials

Support

Any questions? Check our FAQ or feel free to get in touch with us - we would love to help.

Help center

Get started with a few lines of code.

Video Capture
Depth Sensing
Positional Tracking
3D Object Detection
Body Tracking
Spatial Mapping

Explore Docs

C++PythonC#

#include <sl/Camera.hpp>
int main() {
    // Initialize and open the camera
    sl::Camera zed;
    zed.open();

    // Create a matrix to store the image
    sl::Mat image;
    int i = 0;

    while(i++ < 1000){
        // Grab a frame and retrieve the left image
        zed.grab();
        zed.retrieveImage(image, sl::VIEW::LEFT);
    }
    return 0;
}

import pyzed.sl as sl

def main():
    # Initialize and open the camera
    zed = sl.Camera()
    zed.open()

    # Create a matrix to store the image
    image = sl.Mat()
    i = 0

    while i < 1000 :
        i=i+1
        # Grab a frame and retrieve the left image
        zed.grab()
        zed.retrieve_image(image, sl.VIEW.LEFT)

void main() {
    // Initialize and open the camera
    sl.Camera zed = new sl.Camera(0);
    InitParameters init_param = new sl.InitParameters();
    zed.Open(ref init_param);

    // Create a matrix to store the image
    sl.Mat image = new sl.Mat();
    int i = 0;
    sl.RuntimeParameters runtime_param = new sl.RuntimeParameters();
    
    while(i++ < 1000){
        // Grab a frame and retrieve the left image
        zed.Grab(ref runtime_param);
        zed.RetrieveImage(image, sl.VIEW.LEFT);
    }

#include <sl/Camera.hpp>
int main() {
    // Initialize and open the camera
    sl::Camera zed;
    zed.open();

    // Create matrices to store the depth and point cloud
    sl::Mat depth, point_cloud;

    while(true){
        // Grab a frame and retrieve depth and point cloud
        zed.grab();
        zed.retrieveMeasure(depth, sl::MEASURE::DEPTH);
        zed.retrieveMeasure(point_cloud, sl::MEASURE::XYZRGBA);
    }
    return 0;
}

import pyzed.sl as sl

def main():
    # Initialize and open the camera
    zed = sl.Camera()
    zed.open()

    # Create matrices to store the depth and point cloud
    depth = sl.Mat()
    point_cloud = sl.Mat()

    while True :
        # Grab a frame and retrieve depth and point cloud
        zed.grab()
        zed.retrieve_measure(depth, sl.MEASURE.DEPTH)
        zed.retrieve_measure(point_cloud, sl.MEASURE.XYZRGBA)

void main() {
    // Initialize and open the camera
    sl.Camera zed = new sl.Camera(0);
    InitParameters init_param = new sl.InitParameters();
    zed.Open(ref init_param);

    // Create matrices to store the depth and point cloud
    sl.Mat depth = new sl.Mat();
    sl.Mat point_cloud = new sl.Mat();
    sl.RuntimeParameters runtime_param = new sl.RuntimeParameters();
    
    while(true){
        // Grab a frame and retrieve depth and point cloud
        zed.Grab(ref runtime_param);
        zed.RetrieveMeasure(depth, sl.MEASURE.DEPTH);
        zed.RetrieveMeasure(point_cloud, sl.MEASURE.XYZRGBA);
    }
}

#include <sl/Camera.hpp>
int main() {
    // Initialize and open the camera
    sl::Camera zed;
    zed.open();

    // Enable Positional Tracking
    zed.enablePositionalTracking();
    sl::Pose zed_pose;

    while(true){
        // Grab a frame and get the current camera position in space
        zed.grab();
        zed.getPosition(zed_pose, sl::REFERENCE_FRAME::WORLD);
    }
    return 0;
}

import pyzed.sl as sl

def main():
    # Initialize and open the camera
    zed = sl.Camera()
    zed.open()

    # Enable Positional Tracking
    zed.enable_positional_tracking()
    zed_pose = sl.Pose()

    while True :
        # Grab a frame and get the current camera position in space
        zed.grab()
        zed.get_position(zed_pose, sl.REFERENCE_FRAME.WORLD)

void main() {
    // Initialize and open the camera
    sl.Camera zed = new sl.Camera(0);
    InitParameters init_param = new sl.InitParameters();
    zed.Open(ref init_param);

    // Enable Positional Tracking
    PositionalTrackingParameters trackingParams = new PositionalTrackingParameters();
    zed.EnablePositionalTracking(ref trackingParams);
    sl.Pose zed_pose = new sl.Pose();
    sl.RuntimeParameters runtime_param = new sl.RuntimeParameters();
    
    while(true){
        // Grab a frame and get the current camera position in space
        zed.Grab(ref runtime_param);
        zed.GetPosition(ref pose, sl.REFERENCE_FRAME.WORLD);
    }
}

#include <sl/Camera.hpp>
int main() {
    // Initialize and open the camera
    sl::Camera zed;
    zed.open();

    // Enable Object Detection
    zed.enableObjectDetection();
    sl::Objects objects;

    while (true){
        // Grab a frame, retrieve the detected objects 
        // and print their 3D location
        zed.grab();
        zed.retrieveObjects(objects);
        for(auto object : objects.object_list){
            for(auto corner : object.bounding_box){
                std::cout << corner << std::endl;
    }
    return 0;
}

import pyzed.sl as sl

def main():
    # Initialize and open the camera
    zed = sl.Camera()
    zed.open()

    # Enable Object Detection
    zed.enable_object_detection()
    objects = sl.Objects()

    while True :
        # Grab a frame, retrieve the detected objects 
        # and print their 3D location
        zed.grab()
        zed.retrieve_objects(objects)
        for object in objects.object_list:
            print(object.position)

void main() {
    // Initialize and open the camera
    sl.Camera zed = new sl.Camera(0);
    InitParameters init_param = new sl.InitParameters();
    zed.Init(ref init_param);

    // Set Object Detection parameters
    sl.ObjectDetectionParameters obj_det_param = new sl.ObjectDetectionParameters();
    sl.ObjectDetectionRuntimeParameters obj_runtime_param = new sl.ObjectDetectionRuntimeParameters();

    // Enable Object Detection
    zed.EnableObjectDetection(ref obj_det_param);
    sl.Objects objects = new Objects();
    sl.RuntimeParameters runtime_param = new sl.RuntimeParameters();
    
    while(true){
        // Grab a frame, retrieve detected human bodies and print
        // the 3D coordinates of their head
        zed.Grab(ref runtime_param);
        zed.RetrieveObjects(ref objects, ref obj_runtime_param);
        for (int i = 0; i < objects.numObject; i++){
          foreach (Vector3 it in object_frame.objectData[i].boundingBox){
            Console.WriteLine("    " + it);
          }
        }
    }
}

#include <sl/Camera.hpp>
int main() {
    // Initialize and open the camera
    sl::Camera zed;
    zed.open();

    // Set Body Tracking parameters
    sl::ObjectDetectionParameters detection_parameters;
    detection_parameters.detection_model = sl::DETECTION_MODEL::HUMAN_BODY_ACCURATE;
    detection_parameters.enable_tracking = true;

    // Enable Body Tracking
    zed.enablePositionalTracking();
    zed.enableObjectDetection(detection_parameters);
    sl::Objects bodies;

    while (true){ 
        // Grab a frame, retrieve detected 3D human bodies and print
        // the 3D coordinates of their head
        zed.grab();
        zed.retrieveObjects(bodies);
        for(auto body : bodies.object_list){
            std::cout << "Person ID: " << body.id << " | Head 3D coordinates: [" 
                      << body.head_position.x << ", " 
                      << body.head_position.y << ", " 
                      << body.head_position.z << "]" << std::endl;
        }
    }
    return 0;
}

import pyzed.sl as sl

def main():
    # Initialize and open the camera
    zed = sl.Camera()
    zed.open()

    # Set Body Tracking parameters
    detection_parameters = sl.ObjectDetectionParameters()
    detection_parameters.detection_model = sl.DETECTION_MODEL.HUMAN_BODY_ACCURATE
    detection_parameters.enable_tracking = True

    # Enable Body Tracking
    zed.enable_object_detection(detection_parameters)
    zed.enable_positional_tracking()
    bodies = sl.Objects()

    while True :
        # Grab a frame, retrieve detected 3D human bodies and print
        # the 3D coordinates of their head
        zed.grab()
        zed.retrieve_objects(bodies)
        for body in bodies.object_list:
            print("Person ID: {} | Head 3D coordinates: {}".format(body.id, body.head_position))

void main() {
    // Initialize and open the camera
    sl.Camera zed = new sl.Camera(0);
    InitParameters init_param = new sl.InitParameters();
    zed.Open(ref init_param);
    
    // Set Body Tracking parameters
    sl.ObjectDetectionParameters obj_det_param = new sl.ObjectDetectionParameters();
    obj_det_param.detectionModel = sl.DETECTION_MODEL.HUMAN_BODY_ACCURATE;
    sl.ObjectDetectionRuntimeParameters obj_runtime_param = new sl.ObjectDetectionRuntimeParameters();
    obj_det_param.enableObjectTracking = true; 

    // Enable Body Tracking  
    sl.PositionalTrackingParameters trackingParams = new sl.PositionalTrackingParameters(); 
    zed.EnablePositionalTracking(ref trackingParams);                         
    zed.EnableObjectDetection(ref obj_det_param);
    sl.Objects bodies = new sl.Objects();
    sl.RuntimeParameters runtime_param = new sl.RuntimeParameters();

    while(true){
        // Grab a frame, retrieve detected 3D human bodies
        zed.Grab(ref runtime_param);
        zed.RetrieveObjects(ref bodies, ref obj_runtime_param);
        for (int i = 0; i < bodies.numObject; i++){
            sl.ObjectData body = bodies.objectData[i];
            Console.WriteLine("Person ID: " + body.id);
        }
    }

#include <sl/Camera.hpp>
int main() {
    // Initialize and open the camera
    sl::Camera zed;
    zed.open();

    // Enable Spatial Mapping
    zed.enableSpatialMapping();
    int i = 0;

    // Map the scene for 1000 frames
    while (i++ < 1000) zed.grab();

    // Extract and save the map as a mesh
    sl::Mesh mesh;
    zed.extractWholeSpatialMap(mesh);
    mesh.save("mesh.obj");
    return 0;
}

import pyzed.sl as sl

def main():
    # Initialize and open the camera
    zed = sl.Camera()
    zed.open()

    # Enable Spatial Mapping
    zed.enable_spatial_mapping()
    i = 0

    # Map the scene for 1000 frames
    while i < 1000:
        i=i+1
        zed.grab()

    # Extract and save the map as a mesh
    mesh = sl.Mesh()
    zed.extract_whole_spatial_map(mesh)
    mesh.save("mesh.obj")

void main() {
    // Initialize and open the camera
    sl.Camera zed = new sl.Camera(0);
    InitParameters init_param = new sl.InitParameters();
    zed.Open(ref init_param);

    // Enable Spatial Mapping
    SpatialMappingParameters mappingParams = new SpatialMappingParameters();
    zed.EnableSpatialMapping(ref mappingParams);
    int i = 0;
    sl.RuntimeParameters runtime_param = new sl.RuntimeParameters();
    
    // Map the scene for 1000 frames
    while (i++ < 1000) zed.Grab(ref runtime_param);

    // Extract and save the map as a mesh
    zed.ExtractWholeSpatialMap();
    zed.SaveMesh("mesh.obj", sl.MESH_FILE_FORMAT.OBJ);
}

Integrations

Use the ZED with your favorite platforms and libraries. Make sure to check our Docs and GitHub page for the latest integrations!

See all integrations

Optimized for Embedded Platforms

With ZED cameras and NVIDIA Jetson embedded platforms, start building the next generation of smart AI robotics and analytics applications. Get ZED SDK for NVIDIA Jetson.