Rerun

Rerun 0.11 brings all SDKs to parity

Nikolaus West
Written by Nikolaus West 5 months ago

Rerun helps engineers and researchers log and visualize streams of multimodal data. In fields like robotics and augmented reality, that data often lives in programs written in C++. In Rerun 0.10, we released our first version of the Rerun C++ SDK, and with 0.11 it is now fully on par with our two other SDKs in Python and Rust.

Thanks to some great community feedback we've added more options for integrating Rerun in your CMake projects. Rerun 0.11 comes with big improvements to both the performance and ergonomics of logging non-Rerun data. It also includes multiple general performance improvements that bring the C++ SDK on par with the Rust version.

While both performance and nice API's are great, the final and probably most important piece to the C++ puzzle is that 0.11 brings hosted API reference documentation.

In addition to C++ improvements, this version also comes with more control over the time ranges used for e.g. time series plots. We've also deployed the web viewer as a stand alone npm package for easier integration in other tools.

Check out the release notes for a full list of changes.

Full time range queries

Rerun has long had a feature called "Visual History", where you could choose to include previous data for an entity shown in a view. For instance, you could use that to accumulate point clouds that have been observed over time in a 3D scene. In 0.11, we are expanding that feature to a full "Visible Time Range" query where you'll be able to set both the start end end of the time range to include.

An important use case that the "Visible Time Range" feature enables is to show windowed time series plots, which is important for live streaming visualizations. This is the first step in what will be a series of improvements to Rerun's plotting capabilities.

You can try out the new "Visible Time Range" feature right now in your browser at app.rerun.io.

Using Rerun with OpenCV and Eigen in C++

We've put together a minimal C++ example of using Rerun together with OpenCV and Eigen that should hopefully be a good starting off point to both see how to use Rerun with those popular libraries, as well as how you can use Rerun with your own types.

Check out the example here.

Rerun Web Viewer on npm

To make it easier to use Rerun for viewing data on the web, we've published the viewer as a stand alone npm package. For those of you building in React, we also published a React component that you can use directly.

The viewer is super easy to integrate in your web app but you currently only have limited control over options and layout from javascript.

import { WebViewer } from "@rerun-io/web-viewer";

// Either pass the url of an .rrd file
const DATA_SOURCE_URL =
    "https://demo.rerun.io/version/0.11.0/examples/arkit_scenes/data.rrd";
// Or pass the websocket url to a live Rerun stream
// const DATA_SOURCE_URL = "ws://localhost:9877";

const parentElement = document.body;

const viewer = new WebViewer();
await viewer.start(DATA_SOURCE_URL, parentElement);
// …
viewer.stop();

The data that you pass to the Viewer can either come from a websocket connection to the SDK opened via the serve API, or from a hosted .rrd file.

CollectionAdapter gives better logging of non-Rerun types

Rerun 0.11 sunsets ComponentBatchAdaptor in favor of the new CollectionAdapter, which is more expressive and general. The end result is that the code to get data in your own formats logged to Rerun will be simpler and produce fewer unnecessary copies.

The ComponentBatchAdaptor made it easy to map your own types to Rerun's ComponentBatches. For example, if you have a proprietary Vec3D and represent point clouds as std::vector<Vec3D>, you could use the ComponentBatchAdaptor to log it as a Rerun batch of rerun::Position3Ds without incurring extra copies.

However, single images do not fit this pattern and would therefore require an intermediate copy to log. The new CollectionAdapter fixes this in 0.11 by generalizing to inner types in addition to batches.

For example, to log an OpenCV cv::Mat to Rerun as an image, you might write the following adapters:

// Adapters so we can easily borrow an OpenCV image into Rerun images without copying:
template <>
struct rerun::CollectionAdapter<uint8_t, cv::Mat> {
    Collection<uint8_t> operator()(const cv::Mat& img) {
        assert(CV_MAT_DEPTH(img.type()) == CV_8U);
        return Collection<uint8_t>::borrow(img.data, img.total() * img.channels());
    };
};

// Convenience function for extracting the image shape.
rerun::Collection<rerun::TensorDimension> tensor_shape(const cv::Mat& img) {
    return {
        static_cast<size_t>(img.rows),
        static_cast<size_t>(img.cols),
        static_cast<size_t>(img.channels()),
    };
};

And then log it to Rerun like:

cv::cvtColor(img, img, cv::COLOR_BGR2RGB); // Rerun expects RGB format
rec.log("image", rerun::Image(tensor_shape(img), rerun::TensorBuffer::u8(img)));

For images, we've also used the CollectionAdapter to implement a built-in convenience constructor so that you can log your own images to Rerun without having to write an adapter for the tensor buffer:

// Creates an image archetype from a shape and pointer
rec.log("image", rerun::Image(tensor_shape(img), img.data));

Your feedback impacts what we build

The early feedback we got on 0.10 had a big impact on the C++ improvements we shipped in 0.11. We love hearing everything about what's worked for you and how we can improve things. If it's bugging you we'd love to know, even if it seems minor!

Join us on Github or Discord and let us know what you like and what you'd hope to see change in the future.

Privacy policy