Visualization messages can be sent to the LCC to draw basic shapes and text in the map view, where the vehicles are shown as well. An example use case for this would be to draw the desired path that a vehicle is supposed to take on command, to check if it actually follows this path. The messages can also be used to show additional information to the running program or simply to debug the sent trajectory by checking the created path visually.
Data structure
The visualization IDL file looks like this:
#include "Color.idl"
#include "Point2D.idl"
enum VisualizationType
{
LineStrips=0,
Polygon,
StringMessage
};
struct Visualization
{
//Id to be able to delete the viz later on
string id; //@key
VisualizationType type;
unsigned long long time_to_live;
sequence<Point2D> points;
double size; //Line width in pixels or text size in pt
string string_message;
Color color;
};
Each visualization message thus consists of seven data fields which need to be filled accordingly to draw the desired information in the LCC.
ID
Each visualization command is identified by a unique ID. Choose different IDs for commands that should be displayed at the same time, or use the same ID to override an older visualization message.
Visualization Type
Currently, three command types are supported: You can draw a line, a polygon or a string.
Lines and polygons are defined by the points which are set in the structure data as well. In both cases, lines are drawn between subsequent points in the array. The first and the last point are also connected by a line if you want to draw a polygon.
For strings, you need to specifiy a single point where the string is drawn, and you should set the string message that should be displayed.
Time to Live
Each visualization command is removed automatically after a given time. Here, you can set the time to live in nanoseconds.
Points
This field defines the set of points between which lines should be drawn, or the point where the string message should be shown. The coordinate system is the same as the one used for the vehicles.
Points is a custom IDL data type. (see below)
Size
Here you can define the line width or the size of the string message.
String Message
Just set a string for this field (as RTI uses its own string format, be aware that setting this value with a std::string data type might lead to an error message, but give it a try before you use RTI's own implementation).
Color
Lines, polygons and strings can be given any color within the RGB spectrum.
Color is a custom IDL data type. (see below)
Further data structures
struct Point2D {
double x;
double y;
};
Points are just set according to the coordinate system explained elsewhere.
struct Color
{
octet a;
octet r;
octet g;
octet b;
};
Color values are just regular RGB values. The transparency value should be ignored.
Usage example
This example can also be found in the Lab's Git.
#include <chrono>
#include <iostream>
#include <thread>
#include <dds/pub/ddspub.hpp>
#include "cpm/init.hpp"
#include "cpm/Logging.hpp"
#include "cpm/ParticipantSingleton.hpp"
#include "cpm/get_topic.hpp"
#include "cpm/get_time_ns.hpp"
#include "Color.hpp"
#include "Visualization.hpp"
int main(int argc, char *argv[]) {
//Initialize the cpm library
cpm::init(argc, argv);
cpm::Logging::Instance().set_id("Visualization_test");
std::cout << "Creating visualization sender..." << std::endl;
//Create a RTI DataWriter to send visualization messages to the LCC in a reliable way
dds::pub::DataWriter<Visualization> viz_writer(dds::pub::Publisher(cpm::ParticipantSingleton::Instance()), cpm::get_topic<Visualization>("visualization"), dds::pub::qos::DataWriterQos() << dds::core::policy::Reliability::Reliable());
//Creation of a line visualization message ----------------------------
Visualization viz;
viz.id("1");
viz.type(VisualizationType::LineStrips);
viz.time_to_live(3000000000);
viz.size(1.0);
Point2D point1(0.0, 0.0);
Point2D point2(1.0, 1.0);
Point2D point3(2.0, -2.0);
Point2D point4(3.0, 3.0);
Point2D point5(4.0, -4.0);
std::vector<Point2D> viz_points {point1, point2, point3, point4, point5};
viz.points(rti::core::vector<Point2D>(viz_points)); //In newer RTI versions, a conversion of the vector data structure to RTI's own implementation might become obsolete, but it is required here
Color viz_color(255, 0, 255, 255);
viz.color(viz_color);
//Message created -----------------------------------------------------
//Always wait a bit between sending messages, or else messages might get lost
usleep(100000);
std::cout << "Sending visualization line..." << std::endl;
//Send the line visualization message to the LCC
viz_writer.write(viz);
//Creation of a polygon message ---------------------------------------
Visualization viz2;
viz2.id("2");
viz2.type(VisualizationType::Polygon);
viz2.time_to_live(5000000000);
viz2.size(0.05);
Point2D point1_2(0.0, 0.0);
Point2D point2_2(0.5, 0.5);
Point2D point3_2(1.0, 0.0);
std::vector<Point2D> viz2_points {point1_2, point2_2, point3_2};
viz2.points(rti::core::vector<Point2D>(viz2_points));
Color viz2_color(255, 255, 0, 255);
viz2.color(viz2_color);
//Message created -----------------------------------------------------
usleep(100000);
std::cout << "Sending visualization polygon..." << std::endl;
//Send the polygon message
viz_writer.write(viz2);
//Creation of a string message ----------------------------------------
Visualization viz3;
viz3.id("3");
viz3.type(VisualizationType::StringMessage);
viz3.time_to_live(10000000000);
viz3.size(1.0);
Point2D point1_3(0.2, 0.2);
std::vector<Point2D> viz3_points {point1_3};
viz3.points(rti::core::vector<Point2D>(viz3_points));
Color viz3_color(255, 255, 255, 0);
viz3.color(viz3_color);
viz3.string_message("Hello LCC!");
//Message created -----------------------------------------------------
usleep(100000);
std::cout << "Sending visualization string..." << std::endl;
//Send the string message
viz_writer.write(viz3);
std::cout << "Shutting down..." << std::endl;
return 0;
}
Overview
Content Tools