Autonomous Robotics

Camera + Software

We make building smart robots easy.

Robots are machines that need to sense, decide and act.
We make it easy to develop, test and deploy intelligent robotics applications in the field.

Neural Depth Perception

Using neural depth sensing, perceive your surroundings in 3D up to 20m distance, with increased accuracy in close range.

Environment 3D Mapping

Localize your robot and capture a map of your environment using 3D SLAM. ROS compatible.

Spatial AI

Recognize and track 3D objects in real-time for navigation and manipulation.

One Platform, Many Robots.

Popular among robotics engineers, the ZED camera provides vision to many types of robots.

AERIAL

Last Mile Delivery, Agricultural, Security Drones.
MARINE

Underwater Robots for Data Scouting.

GROUND

Transportation, Agricultural, Retail, Security, Defense.
INDUSTRIAL

Robotic Arms, Forklifts, Mobile Picking Robots.

Make your robot see 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);
}

Build with ROS and more

See all integrations

More than
90,000 developers

Join the ZED community and start building intelligent machines with the ZED SDK and its plugins.

Get ZED SDK View Github

Explore Docs

Why Robotics Engineers choose ZED?

Our cameras come with many benefits: a quick integration that saves months of tests and trials, low level control and built-in computer vision and AI technology for fast-paced projects.

Complete 3D Vision Pipeline

From neural depth perception to SLAM and 3D AI, everything you need to make your robot smarter.

High-quality RGB Sensors

Capture high-resolution, high-frame rate RGB images with best-in-class image quality that will boost your AI accuracy.

Works Indoors and Outdoors

Unlike active and IR sensors, the ZED camera is robust to changing light conditions and strong sunlight.

Synchronization of Image, Depth and IMU

No post-processing needed, all the data is accurately synchronized between the cameras multiple sensors.

Low Latency

Benefit from an optimized 3D vision pipeline that guarantees the lowest latency in the market.

Optimized for Embedded Platforms

Our cameras and software are optimized and well-tested on NVIDIA Jetson boards.

''The ZED camera unmatched resolution, frame rate and its ease of integration makes it one of the most powerful 3D camera.''

Sertak K., MIT

''I've been in robotics for many years now, and the quality of these stereo cameras for the price is a real game changer.''

Paul D., BOOZ ALLEN

''The Jetson community is very excited by what Stereolabs has achieved with the ZED.''

Deepu T., VP and GM Tegra, NVIDIA

''Stereolabs gives us the feeling, from the first ZED we bought, that we are important. We are sure this attitude brought Stereolabs to its position in the market and will make it a market leader for years to come.''

Wonder Robotics

Success Stories

See how our customers use the ZED to build smart robots.

Ski Robots at Winter Olympics

ZED Powers Autonomous Ski Robots at the Winter Olympic Games.

NVIDIA Delivery Robot

At NVIDIA, Popcorn Delivery Robot Bears Kernel of Innovation.

OpenZeka Autonomous Rovers

Autonomous Rovers Race for OpenZeka Competition with ZED.

Featured Products

All-in-one 3D perception platform for robots

Remotely monitor human activity and spaces

Build new immersive experiences with Spatial AI

Deliver large-scale XR experiences

The leading depth camera for intelligent robots.

We make building smart robots easy.

Neural Depth Perception

Environment 3D Mapping

Spatial AI

One Platform, Many Robots.

AERIAL

MARINE

GROUND

INDUSTRIAL

Make your robot see with a few lines of code.

Build with ROS and more

More than
90,000 developers

Why Robotics Engineers choose ZED?

Complete 3D Vision Pipeline

High-quality RGB Sensors

Works Indoors and Outdoors

Synchronization of Image, Depth and IMU

Low Latency

Optimized for Embedded Platforms

Success Stories

Ski Robots at Winter Olympics

NVIDIA Delivery Robot

OpenZeka Autonomous Rovers

Featured Products

ZED XNew

ZED X MiniNew

ZED Box

All-in-one 3D perception platform for robots

Remotely monitor human activity and spaces

Build new immersive experiences with Spatial AI

Deliver large-scale XR experiences

The leading depth camera for intelligent robots.

We make building smart robots easy.

Neural Depth Perception

Environment 3D Mapping

Spatial AI

One Platform, Many Robots.

AERIAL

MARINE

GROUND

INDUSTRIAL

Make your robot see with a few lines of code.

Build with ROS and more

More than 90,000 developers

Why Robotics Engineers choose ZED?

Complete 3D Vision Pipeline

High-quality RGB Sensors

Works Indoors and Outdoors

Synchronization of Image, Depth and IMU

Low Latency

Optimized for Embedded Platforms

Success Stories

Ski Robots at Winter Olympics

NVIDIA Delivery Robot

OpenZeka Autonomous Rovers

Featured Products

ZED XNew

ZED X MiniNew

ZED Box

More than
90,000 developers