Telekinesis Agentic Skill Library

Appearance

RealSense: Stream Live Depth Video ​

SUMMARY

Connect to a RealSense camera, stream continuous depth frames for 10 seconds with a colour map applied, and visualise the live feed with Rerun.

Example ​

Code ​

python
"""
A simple example demonstrating how to connect to a RealSense camera, stream a
video and disconnect from the camera when finished.

Please run this example from a terminal to avoid issues with rerun's spawn mode.
"""

import time
from loguru import logger

import rerun as rr

from telekinesis.medulla.cameras import realsense


def main():
    camera = realsense.RealSense(
        name="my_realsense",
    )
    try:
        rr.init("RealSense_Video_Example", spawn=True)
        camera.connect()

        end_time = time.time() + 10
        while time.time() < end_time:
            depth_image = camera.capture_video_depth_frame()
            rr.log(
                "Continuous_Depth_Image_Capture", 
                rr.DepthImage(
                    depth_image,
                    meter=1.0, # values are already in metres
                    colormap="turbo",
                    depth_range=(0.0, 3.0) # 0–3 metres
                )
            )
    except Exception as e:
        logger.error(
            f"Unable to stream video. Caught exception: {type(e).__name__}: {e}"
        )
    finally:
        camera.disconnect()


if __name__ == "__main__":
    main()

Explanation ​

Now, let's break down the code piece by piece.

A RealSense camera object is created with just a name. No serial number is required — the class connects to the first available device automatically.

python
camera = realsense.RealSense(
    name="my_realsense",
)

A Rerun viewer is opened with rr.init(..., spawn=True), then camera.connect() initializes the RealSense pipeline with default stream settings and makes the device ready to capture frames.

python
rr.init("RealSense_Video_Example", spawn=True)
camera.connect()

The streaming loop runs for 10 seconds using a wall-clock deadline rather than a fixed frame counter. Each call to capture_video_depth_frame keeps the depth stream running continuously between calls and returns one frame as a NumPy array of float values already in metres. Unlike the colour video example, no None guard is needed here — the depth stream always returns a valid frame once the pipeline is running.

Each frame is logged as a rr.DepthImage with the same display settings on every iteration: meter=1.0 tells Rerun the values are already in metres, colormap="turbo" maps close distances to blue and far distances to red, and depth_range=(0.0, 3.0) clamps the colour scale to the 0–3 metre range.

python
end_time = time.time() + 10
while time.time() < end_time:
    depth_image = camera.capture_video_depth_frame()
    rr.log(
        "Continuous_Depth_Image_Capture",
        rr.DepthImage(
            depth_image,
            meter=1.0,
            colormap="turbo",
            depth_range=(0.0, 3.0)
        )
    )

The finally block guarantees that camera.disconnect() is always called, stopping the RealSense pipeline and releasing all USB resources regardless of whether an exception occurred.

python
finally:
    camera.disconnect()

Run ​

bash
python capture_depth_video_example.py

A Rerun viewer opens automatically. Depth frames stream under Continuous_Depth_Image_Capture for 10 seconds with the turbo colour map applied, then the camera disconnects cleanly.