ROS Compatibility

Ark supplies a few helper classes and systems for interacting with ROS data. At the moment, the best way to interact with ROS data is to open a ROS bag file (with the ark::ros::BagReader class), iterate through the objects within, and convert those into equivalent Ark types.

The BagReader class will produce BaggedObject structures, which contain the raw bytes of a rosmsg file. Because bag files contain the schemas of the rosgmsg types, we can deserialize them on the fly and you can use the Ark reflection APIs (Object) to access their contents.

Reading Bags

You can programmatically read through bag files with the ark::ros::BagReader API:

#include "ark/ros/rosbag_reader.hh"

ark::ros::BagReader reader("path/to/log.bag");

while (auto object = reader.step())
    std::cout << object->topic_name << std::endl;

Each BaggedObject structure contains the system time that the object was logged at, the topic name, and the raw bytes. To deserialize data, you must parse the definitions. A convenient helper class exists with ark::ros::RosmsgRegistry. To load the registry with messages from a bag, you can do something like this:

#include "ark/ros/rosmsg_registry.hh"

ark::ros::RosmsgRegistry registry;

for (const auto &topic : reader.topics())
    registry.add_type(topic.type, topic.definition);

From there, you can deserialize the object (and print it as JSON):

#include "ark/serialization/object.hh"

auto decoded = registry.deserialize(object->type, object->payload);

std::cout << decoded->json().str << std::endl;

Under the hood, this is using an rbuf backend to decode all of the objects, so you can use the same ark::serialization::Object APIs to inspect all of the data.


You can use the ark-rosbag-tool command to inspect ROS bag files, list topics, message definitions, and even deserialize the data in the bag files, using the Ark APIs. This can allow you to inspect ROS data without having ROS installed on your local system.

For example, to list the topics:

./build/ark-rosbag-tool ./cartographer_paper_deutsches_museum.bag -l
TYPE                                     TOPIC
sensor_msgs/MultiEchoLaserScan           vertical_laser_2d
sensor_msgs/Imu                          imu
sensor_msgs/MultiEchoLaserScan           horizontal_laser_2d

You can also list the rosmsg definition for a particular topic:

./build/ark-rosbag-tool ./cartographer_paper_deutsches_museum.bag --definition imu
# This is a message to hold data from an IMU (Inertial Measurement Unit)
# ...

Header header

geometry_msgs/Quaternion orientation
float64[9] orientation_covariance # Row major about x, y, z axes

geometry_msgs/Vector3 angular_velocity
float64[9] angular_velocity_covariance # Row major about x, y, z axes

geometry_msgs/Vector3 linear_acceleration
float64[9] linear_acceleration_covariance # Row major x, y z

Finally, you can dump the messages inside the bag file:

./build/ark-rosbag-tool ./cartographer_paper_deutsches_museum.bag -d -t imu
  "angular_velocity": {
    "x": 0.010483813472092152,
    "y": -0.004174433648586273,
    "z": 0.0037074105348438038
  "header": {
    "frame_id": "imu_link",
    "seq": 0,
    "stamp": 1432647016483952200

rosmsg Support

There is a rosmsg frontend for rbuf that you can make use of (with some effort), through the ark::ros::RosmsgParser class. This allows you to parse a msg definition (with all of its dependents in the same file) and will produce an ark::serialization::SchemaRegistry object.

From there, you could produce C++ (or JavaScript/Python) code to read in the rosmsg content. If you are just using reflection, it is probably better to just use the ark::ros::RosmsgRegistry class instead (see above).