Interactive Experiences

Camera + Software

A complete platform for creators of live interactive experiences.

Brands and agencies are shifting towards 3D and real-time in their marketing and creative strategies. We make it easy to develop, test and deploy live experiences that drive high consumer engagement.

Multi-person tracking

Detect and track people in 3D space with a wide field of view and model where they are in a room, store or exhibition venue.

Depth-aware visual effects

Bring real-time 3D sensing to Unity and Unreal engines and create innovative experiences that mix the real and virtual worlds.

Deploy indoors and outdoors

Build and deploy exciting multi-user experiences in any type of indoors or outdoors environment.

Integrations

Build depth-aware applications in minutes using the ZED SDK, its plugins and integrations.

Bring your ideas to life 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);
}

I don't think we could've pulled off this project without the ZED.

Patrick S., PuzzleFox Interactive

The ZED camera is the only camera that provided us with a dense depth map robust to light changing conditions in retail stores.

Alan S., Sapient Razorfish