Marker display for custom visualization in ROS - Deep Dive

Overview - Marker display for custom visualization

What is it?

Marker display for custom visualization in ROS allows you to create and show shapes, lines, text, and other visual elements in 3D space within tools like RViz. It helps developers visualize data, robot states, or sensor information in a clear and interactive way. These markers are messages sent over ROS topics that RViz listens to and renders accordingly. This makes debugging and understanding robot behavior much easier.

Why it matters

Without marker display, developers would struggle to see what the robot perceives or plans, making debugging and development slow and error-prone. Marker visualization bridges the gap between raw data and human understanding by showing meaningful graphics in the robot's environment. It improves communication between the robot and its developers, leading to faster development and safer robots.

Where it fits

Before learning marker display, you should understand ROS topics, messages, and basic RViz usage. After mastering marker display, you can explore advanced visualization techniques, interactive markers, and custom RViz plugins to create richer user interfaces.

Mental Model

Core Idea

Marker display is like sending drawing instructions to a shared whiteboard that everyone watching can see and update in real time.

Think of it like...

Imagine you and your friends are planning a route on a map by drawing lines and shapes with colored markers on a big whiteboard. Each friend can add or erase marks to show ideas or changes. Marker display in ROS works the same way by sending drawing commands that RViz shows as shapes and lines in 3D space.

┌─────────────────────────────┐
│ ROS Node                   │
│  ┌─────────────────────┐  │
│  │ Marker Publisher    │  │
│  │ (sends Marker msgs) │  │
│  └─────────────────────┘  │
│             │              │
│             ▼              │
│  ┌───────────────────────────────┐  │
│  │ ROS Topic: /visualization_marker │  │
│  └───────────────────────────────┘  │
│             │              │
│             ▼              │
│  ┌─────────────────────┐  │
│  │ RViz Marker Display │  │
│  │ (renders markers)   │  │
│  └─────────────────────┘  │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding ROS Markers Basics

Concept: Learn what a Marker message is and how it represents shapes and visuals in ROS.

A Marker is a special ROS message type that describes a shape, color, size, and position to be drawn in RViz. Common shapes include spheres, cubes, arrows, and lines. Each marker has an ID and a namespace to manage multiple markers. You publish these Marker messages on a topic that RViz listens to, and RViz draws them accordingly.

Result

You can send simple shapes like a red sphere or a blue arrow to RViz and see them appear in the 3D view.

Understanding the Marker message structure is key to creating any custom visualization in ROS.

2

Foundation

Setting Up RViz for Marker Display

Concept: Learn how to configure RViz to subscribe to marker topics and display them.

Open RViz and add a 'Marker' display type. Set the topic to the one your node publishes markers on, usually '/visualization_marker'. Adjust the fixed frame to match your robot's coordinate frame (e.g., 'map' or 'base_link'). Once set, RViz will show any markers published on that topic.

Result

RViz shows the markers you publish, allowing you to see your custom shapes in the robot's environment.

Knowing how to connect RViz to marker topics lets you instantly visualize your robot's data.

3

Intermediate

Publishing Custom Markers Programmatically

🤔Before reading on: Do you think you can change a marker's color and size by modifying its message fields or do you need special RViz settings? Commit to your answer.

Concept: Learn how to create and publish Marker messages in your ROS node code to customize appearance and behavior.

In your ROS node, create a Marker message and set its type (e.g., SPHERE, CUBE), position, orientation, scale, and color fields. Assign a unique ID and namespace. Publish this message repeatedly on the marker topic. For example, to show a green cube at (1, 2, 0), set the position and color fields accordingly. RViz will update the display as new messages arrive.

Result

Your robot's program controls exactly what shapes appear, where, and how they look in RViz.

Knowing that marker appearance is fully controlled by message fields empowers you to create dynamic and meaningful visualizations.

4

Intermediate

Managing Multiple Markers and Lifetimes

🤔Before reading on: If you publish a marker once, will it stay forever in RViz or disappear after some time? Commit to your answer.

Concept: Learn how to handle multiple markers and control how long they stay visible.

Each marker has an ID and namespace to distinguish it from others. You can publish many markers by changing these IDs. The 'lifetime' field controls how long a marker stays visible if not updated. Setting lifetime to zero means the marker stays until explicitly deleted or replaced. To remove a marker, publish it with action DELETE. This helps keep your visualization clean and up to date.

Result

You can show many markers simultaneously and control their visibility duration.

Understanding marker IDs and lifetimes prevents clutter and ensures your visualization reflects the current robot state.

5

Intermediate

Using Marker Arrays for Complex Visuals

Concept: Learn how to publish multiple markers together efficiently using MarkerArray messages.

MarkerArray is a message type that holds a list of Marker messages. Publishing a MarkerArray lets you send many markers in one message, reducing communication overhead. This is useful for visualizing complex objects like point clouds, paths, or multiple detected objects. RViz renders all markers in the array at once.

Result

You can efficiently display many markers together, improving performance and organization.

Using MarkerArray is essential for scalable and performant visualizations involving many elements.

6

Advanced

Interactive Markers for User Interaction

🤔Before reading on: Do you think markers in RViz can be clicked and moved by users by default? Commit to your answer.

Concept: Learn about interactive markers that allow users to manipulate markers in RViz with mouse actions.

Interactive markers extend basic markers by adding controls like move, rotate, and menu options. They use a special InteractiveMarker message and server to handle user input. This lets users adjust robot goals, manipulate objects, or trigger actions directly in RViz. You create interactive markers by defining controls and callbacks in your ROS node.

Result

Users can interact with markers in RViz, making visualization a two-way communication tool.

Interactive markers transform visualization from passive display to active user interface, enhancing robot control.

7

Expert

Optimizing Marker Display for Large Data Sets

🤔Before reading on: Is it efficient to publish thousands of individual markers separately or is there a better approach? Commit to your answer.

Concept: Learn techniques to efficiently visualize large numbers of markers without slowing down RViz or ROS communication.

Publishing thousands of individual markers can overwhelm ROS topics and RViz rendering. To optimize, use MarkerArray to batch markers, minimize marker updates by only publishing changes, and use simpler marker types. Also, consider using point cloud visualization for dense data instead of many markers. Properly managing marker lifetimes and deleting unused markers prevents memory leaks in RViz.

Result

Your visualization remains smooth and responsive even with complex or large data sets.

Knowing how to optimize marker publishing is critical for real-world applications with heavy visualization needs.

Under the Hood

Marker display works by sending ROS messages that describe geometric shapes and their properties. These messages travel over ROS topics using the publish-subscribe system. RViz subscribes to these topics and interprets the Marker messages to render 3D shapes in its OpenGL-based viewer. Each marker message includes fields for position, orientation, scale, color, and action (add, modify, delete). RViz maintains an internal cache of markers keyed by namespace and ID to update or remove them as new messages arrive.

Why designed this way?

The design leverages ROS's flexible messaging system to decouple visualization from robot logic, allowing any node to publish markers independently. Using standard message types ensures compatibility and extensibility. The namespace and ID system allows multiple markers to coexist without conflict. The lifetime field provides automatic cleanup to avoid stale visuals. This approach avoids embedding visualization code inside robot nodes, promoting modularity and reuse.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ ROS Publisher │──────▶│ ROS Topic     │──────▶│ RViz Marker   │
│ (Marker msgs) │       │ /visualization_marker │ Display       │
└───────────────┘       └───────────────┘       └───────────────┘
       ▲                                              │
       │                                              ▼
┌───────────────┐                               ┌───────────────┐
│ Robot or      │                               │ OpenGL Renderer│
│ Sensor Nodes  │                               │ Draws Markers │
└───────────────┘                               └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: If you publish a marker once, will it stay visible forever in RViz? Commit to yes or no.

Common Belief: Publishing a marker once makes it stay visible indefinitely in RViz.

Reality: Markers disappear after their lifetime expires unless continuously republished or lifetime is set to zero.

Why it matters: Assuming markers persist can cause confusion when visuals vanish unexpectedly, leading to wasted debugging time.

Quick: Can you publish markers on any ROS topic name and RViz will show them? Commit to yes or no.

Common Belief: RViz automatically displays markers from any topic without configuration.

Reality: RViz only displays markers from topics explicitly added and configured in its interface.

Why it matters: Not configuring RViz properly leads to invisible markers, causing frustration and wasted effort.

Quick: Do interactive markers work exactly like normal markers but with added features? Commit to yes or no.

Common Belief: Interactive markers are just normal markers with extra controls and require no additional setup.

Reality: Interactive markers require a special server and message type; they are a separate system from basic markers.

Why it matters: Confusing these leads to failed attempts at interaction and wasted development time.

Quick: Is it efficient to publish thousands of individual markers separately? Commit to yes or no.

Common Belief: Publishing many individual markers separately is fine and won't affect performance.

Reality: Publishing many markers individually can overload ROS communication and RViz rendering, causing lag.

Why it matters: Ignoring this causes slow or crashing visualization tools, hindering robot development.

Expert Zone

1

Markers use a combination of namespace and ID to uniquely identify each visual element; misunderstanding this causes marker overwrites or duplicates.

2

The lifetime field can be used strategically to create temporary visual cues that automatically disappear without manual deletion.

3

Interactive markers require careful synchronization between the server and client to avoid inconsistent states or lost user inputs.

When NOT to use

Marker display is not suitable for extremely high-frequency or dense data visualization like raw point clouds; use dedicated point cloud visualization tools instead. For complex user interfaces, consider custom RViz plugins or external GUIs. Avoid markers for critical real-time control feedback where latency matters.

Production Patterns

In production, marker display is often used for debugging sensor data, showing planned robot paths, visualizing detected objects, and providing user interaction points. Developers batch markers using MarkerArray, manage lifetimes carefully, and combine markers with other RViz displays for comprehensive situational awareness.

Connections

Publish-Subscribe Messaging Pattern

Marker display builds on the ROS publish-subscribe messaging system.

Understanding how messages flow in ROS helps grasp how marker updates propagate and how to design efficient visualization pipelines.

Graphical User Interface (GUI) Event Handling

Interactive markers relate to GUI event handling by processing user inputs and updating visuals accordingly.

Knowing GUI event loops and callbacks clarifies how interactive markers respond to user actions in RViz.

Real-Time Systems

Marker display performance impacts real-time robot control and monitoring.

Appreciating real-time constraints helps optimize marker publishing frequency and complexity to avoid slowing down critical robot functions.

Common Pitfalls

#1 Markers disappear unexpectedly after publishing once.

Wrong approach:

marker.lifetime = ros::Duration(5.0); // publish once and expect permanent display

Correct approach:

marker.lifetime = ros::Duration(0); // zero means marker stays until deleted or replaced

Root cause:

Misunderstanding the lifetime field causes markers to vanish after the set duration.

#2 Markers overwrite each other unintentionally.

Wrong approach:

Publishing multiple markers with the same namespace and ID without changing them.

Correct approach:

Assign unique IDs or namespaces to each marker to prevent overwriting.

Root cause:

Not managing marker IDs and namespaces leads to conflicts in RViz rendering.

#3 Interactive markers do not respond to user input.

Wrong approach:

Using normal Marker messages and expecting interaction without an interactive marker server.

Correct approach:

Set up an InteractiveMarkerServer and publish InteractiveMarker messages with controls.

Root cause:

Confusing basic markers with interactive markers and missing required infrastructure.

Key Takeaways

Marker display in ROS lets you visualize robot data by sending shape and color instructions to RViz.

Markers are controlled by message fields like position, scale, color, and lifetime, which determine their appearance and duration.

Managing marker IDs and namespaces is essential to avoid visual conflicts and maintain clarity.

Interactive markers add user interaction capabilities but require special setup beyond basic markers.

Optimizing marker publishing is crucial for performance when visualizing large or complex data sets.

Practice

1. What is the main purpose of using markers in ROS visualization tools like RViz?

easy

A. To control the robot's movement directly

B. To send commands to the robot's motors

C. To draw shapes in 3D space to help visualize robot data

D. To store robot configuration files

Solution

1. Step 1: Understand marker usage in ROS

   Markers are used to create visual shapes like arrows, cubes, or spheres in RViz to represent data.

2. Step 2: Differentiate markers from control commands

   Markers do not control robot movement or store files; they only help visualize data.

3. Final Answer:

   To draw shapes in 3D space to help visualize robot data -> Option C

4. Quick Check:

   Markers visualize data = B [OK]

Hint: Markers show shapes for visualization, not control [OK]

Common Mistakes:

• Thinking markers control robot movement
• Confusing markers with configuration files
• Assuming markers send commands to motors

2. Which of the following is the correct way to set the type of a marker to a sphere in ROS using the visualization_msgs/Marker message?

easy

A. marker.type = visualization_msgs::Marker::SPHERE;

B. marker.type = visualization_msgs::Marker::CUBE;

C. marker.type = visualization_msgs::Marker::LINE_STRIP;

D. marker.type = visualization_msgs::Marker::TEXT_VIEW_FACING;

Solution

1. Step 1: Identify marker type constants

   ROS defines marker types like CUBE, SPHERE, LINE_STRIP, TEXT_VIEW_FACING as constants in visualization_msgs::Marker.

2. Step 2: Match sphere type

   The constant for a sphere is visualization_msgs::Marker::SPHERE.

3. Final Answer:

   marker.type = visualization_msgs::Marker::SPHERE; -> Option A

4. Quick Check:

   SPHERE type constant = A [OK]

Hint: Use Marker::SPHERE constant to set sphere type [OK]

Common Mistakes:

• Using CUBE instead of SPHERE
• Confusing LINE_STRIP with sphere
• Using text marker type for shapes

3. Given the following ROS Python code snippet, what will be the color of the marker displayed in RViz?

marker.color.r = 0.0
marker.color.g = 1.0
marker.color.b = 0.0
marker.color.a = 0.5

medium

A. Opaque red

B. Fully transparent (invisible)

C. Opaque blue

D. Semi-transparent green

Solution

1. Step 1: Analyze RGB color values

   Red = 0.0, Green = 1.0, Blue = 0.0 means pure green color.

2. Step 2: Check alpha (opacity) value

   Alpha = 0.5 means 50% transparency, so semi-transparent.

3. Final Answer:

   Semi-transparent green -> Option D

4. Quick Check:

   Green=1 and alpha=0.5 = D [OK]

Hint: Alpha <1 means transparency; RGB sets color [OK]

Common Mistakes:

• Ignoring alpha and assuming opaque
• Mixing up RGB values for color
• Thinking alpha=0.5 means fully transparent

4. You wrote this ROS C++ code to publish a marker, but the marker does not appear in RViz. What is the likely error?

visualization_msgs::Marker marker;
marker.header.frame_id = "map";
marker.type = visualization_msgs::Marker::SPHERE;
marker.action = visualization_msgs::Marker::ADD;
marker.pose.position.x = 1.0;
marker.pose.position.y = 2.0;
marker.pose.position.z = 0.0;
marker.scale.x = 0.5;
marker.scale.y = 0.5;
marker.scale.z = 0.5;
marker.color.r = 1.0;
marker.color.g = 0.0;
marker.color.b = 0.0;
marker.color.a = 1.0;
marker_pub.publish(marker);

medium

A. Incorrect marker type used

B. Missing setting of marker.header.stamp to current time

C. Scale values are too small to see

D. Color alpha is zero making it invisible

Solution

1. Step 1: Check marker header completeness

   ROS markers require header.stamp to be set to current time for RViz to display them properly.

2. Step 2: Verify other parameters

   Marker type, scale, and color are valid and visible; alpha is 1.0 (opaque).

3. Final Answer:

   Missing setting of marker.header.stamp to current time -> Option B

4. Quick Check:

   Header stamp missing = A [OK]

Hint: Always set header.stamp to ros::Time::now() [OK]

Common Mistakes:

• Forgetting to set header.stamp
• Using zero alpha making marker invisible
• Assuming scale too small to see

5. You want to display multiple markers at different positions using a single ROS publisher. Which approach correctly updates and publishes markers to show all of them in RViz?

hard

A. Publish each marker separately with unique IDs and the same topic

B. Publish only the last marker repeatedly, ignoring others

C. Publish markers with the same ID to overwrite previous ones

D. Publish markers without setting frame_id to avoid errors

Solution

1. Step 1: Understand marker IDs and topics

   Each marker must have a unique ID to be displayed simultaneously on the same topic.

2. Step 2: Avoid overwriting markers

   Publishing markers with the same ID overwrites previous ones, so unique IDs are needed.

3. Final Answer:

   Publish each marker separately with unique IDs and the same topic -> Option A

4. Quick Check:

   Unique IDs per marker = C [OK]

Hint: Use unique IDs for each marker on one topic [OK]

Common Mistakes:

• Using same ID for multiple markers
• Publishing only one marker and expecting all to show
• Not setting frame_id causing display errors