Only released in EOL distros:
Contains the ROS Visualization Engine (RVE), which is a set of libraries useful for developing 3D visualization tools.
- Author: Josh Faust
- License: BSD,Creative Commons
- Source: hg https://kforge.ros.org/visengine/hg (branch: default)
Development on this stack is discontinued.
The visualization_engine stack (also known as RVE) is a framework for developing 3D visualization tools. The goal of RVE is to provide enough functionality to build rviz2 as a GUI on top of it.
While the overall goal of the stack is 3D visualization, there are also a number of underlying technologies that have been developed that may be useful on their own. These packages are currently prefixed by rve_, but if they're proven useful may get promoted upwards.
The packages in RVE can be thought of as belonging to 4 different categories. There are infrastructure packages, which may be useful outside of RVE. Second, there are message/interface packages, which provide messages that are specific to RVE. Third, there are rendering packages, which handle the various aspects of 3D rendering. Last, there are meta-visualization packages, which provide higher-level functionality on top of the infrastructure and rendering packages.
These packages may be useful outside of RVE, and may be promoted to a higher level at some point. They're being released under the RVE name in order to prove their use and evolve their APIs under real-world use. They also tend to make assumptions about how they're being used that will need to be fixed before they can be promoted out of RVE.
Note that anything here that says it's cross-platform really means it has been abstracted so that alternate platforms can be easily implemented. The only currently tested platform is posix.
rve_dynlib provides a cross-platform low-level dynamic loading interface.
rve_rpc is a service-like implementation built on top of topics. This means it can take advantage of roscpp's no-copy intraprocess message passing. It also has an asynchronous API (though this could be built for services as well).
rve_properties is a property tree system meant for loading/storing arbitrary configuration data.
The message/interface packages are:
These packages handle the interfaces to rendering 3D data in a scene. RVE's renderer is split into two parts, the client and the server. Splitting it this way provides a number of advantages:
The initial goal with the client/server was to model an Active Object, which allows all rendering to happen in a separate thread from, say, the UI. Because we use rve_rpc for this, it extends to being able to run the render server in another process as well, or even across the network (on, say, a cluster machine).
- It allows more control over the rendering being done. Everything going through a custom rendering pipeline (as opposed to direct access to Ogre) allows uniform support for picking, lighting, etc.
- It opens the possibility of implementing an alternate renderer. For example, one could implement a realtime raytracing renderer for generating super high-quality screenshots or movies
The rendering-related packages themselves are:
rve_render_client provides a client interface to the render server.
The meta-visualization packages map to higher-level concepts useful for writing visualization tools. For example, rve_transformer package creates a Transformer concept that is similar to but more powerful than an rviz Display, the goal being to turn some input data (generally a topic) into renderable output. GUI code that may be useful to multiple projects also fits into this category.
rve_transformer provides an interface and management of high-level Transformer objects, which turn data from one form into another. This includes, for example, both turning a topic into something rendered, and turning mouse/keyboard input into camera movement.
rve_common_transformers provides some common transformers, and will be fleshed out in time.
rve_qt has useful Qt widgets, such as a widget which renders an RVE scene