Dataset Viewer

The dataset viewer is not available because its heuristics could not detect any supported data files. You can try uploading some data files, or configuring the data files location manually.

YAML Metadata Warning:empty or missing yaml metadata in repo card

Check out the documentation for more information.

BP-Varich Benchmark Experiments

This is a ROS 2 package written in Python, designed for conducting benchmark experiments as part of a bachelor’s thesis. It provides performance, quality, and visualization testing using benchmark entry points and pipelines defined through YAML configurations.

The package includes monitoring and visualization nodes, as well as other auxiliary components for robotic tasks such as AprilTag Detection, DNN Inference (including segmentation), and Visual SLAM. It also includes auxiliary tools for preparing and managing benchmark experiments.

Getting Started
Core Components
ROS 2 Nodes
Metrics
Visualization
Tools
Contacts
License

Getting Started

To use this ROS 2 package, clone the repository from Hugging Face:

cd ~/ros2_ws/src
git clone https://huggingface.co/datasets/dvar1ch/bp_varich_benchmark_experiments.git

Then install dependencies and build the workspace:

# Update system packages
sudo apt-get update

# Install ROS 2 dependencies
rosdep install --from-paths src --ignore-src -r -y

## Install Python dependencies
pip3 install -r src/bp_varich_benchmark_experiments/requirements.txt --break-system-packages

# Build the workspace
colcon build --symlink-install --base-paths src --packages-select bp_varich_benchmark_experiments

# Source the workspace
source install/setup.bash

Core Components

Benchmark Entry Point

This script serves as a universal entry point for running ROS 2 benchmarking experiments based on a YAML configuration. It provides a generalized framework that dynamically constructs and executes a perception pipeline using the ros2_benchmark infrastructure. The configuration defines which nodes are included in the benchmark, how they are connected to each other, under which conditions they should be activated, and also specifies parameters for the ros2_benchmark test.

During execution, the script loads the specified YAML file, parses node definitions, and separates them into composable and regular ROS 2 nodes. It then applies conditional logic and context-based variable substitution, enabling flexible and configurable experimental scenarios. Composable nodes are grouped into a single ROS 2 container for more efficient execution, while regular nodes are launched independently.

Finally, the benchmark is executed through the ROS2BenchmarkTest interface, which manages the experiment lifecycle and collects performance metrics. This architecture allows the same entry point to be reused across different scenarios without modifying the Python code, making the system fully configuration-driven and extensible.

Pipeline Entry Point

This script serves as a universal entry point for launching ROS 2 perception pipelines based on a YAML configuration file. It dynamically builds a ROS 2 node graph that defines the full runtime structure of the system, including both composable and regular nodes. Unlike the benchmarking entry point, its primary purpose is to execute a functional pipeline rather than measure performance.

At runtime, the script loads the YAML configuration, parses node definitions, and constructs the corresponding ROS 2 graph. It supports conditional node inclusion, context-based variable substitution, and flexible container-level configuration. This allows different pipeline variants to be defined purely through configuration without modifying the underlying Python code.

Composable nodes are grouped into a single ROS 2 component container to improve execution efficiency, while regular nodes are launched separately. The resulting graph is then executed using a launch system based on OpaqueFunction, which dynamically resolves the pipeline structure at launch time.

Overall, this entry point provides a fully configuration-driven mechanism for assembling and running ROS 2 pipelines, enabling flexible experimentation, modular system design, and easy reconfiguration of perception workflows.

Configuration

The templates directory contains ready-to-use configuration templates designed to support different system modes: performance.yaml, quality.yaml, and visualizer.yaml. These templates allow users to quickly launch standard scenarios without the need to manually construct configurations from scratch.

The performance.yaml and quality.yaml files are used for running ROS 2 benchmarking experiments via universal_benchmark.py. They define the standard structure of a benchmark configuration, including execution parameters, pipeline definition, and context variables. The ros2_benchmark_config section contains the core benchmark execution settings, the context section defines variables used for parameter substitution across nodes, and the nodes section describes the benchmark pipeline graph.

The visualizer.yaml configuration is intended for running a ROS 2 pipeline in visualization mode via universal_pipeline.launch.py. Unlike benchmark configurations, it includes a launch section for runtime system settings such as container configuration and launch parameters. It also contains context for variable substitution and nodes for defining the visualization pipeline.

To use any of the templates, the corresponding file should be copied and optionally modified for the specific use case. The system can then be launched using the appropriate command: for benchmarking, launch_test benchmarks/universal_benchmark.py config:=<path_to_config> is used, while for visualization, the pipeline is started with ros2 launch launch/universal_pipeline.launch.py config:=<path_to_config>.

ROS 2 Nodes

AprilTag Monitor Node

This ROS 2 node monitors AprilTag detections and computes aggregated statistics for performance and quality evaluation. It subscribes to detection messages, processes them using an internal metrics engine, and produces both lifetime and rolling-window statistics.

The node periodically publishes statistics snapshots in JSON format to a ROS topic, enabling real-time monitoring of detection performance. Additionally, it can store a final report to disk upon shutdown. The metrics include detection rates, frame timing, dropout analysis, and other quality indicators, making the node suitable for benchmarking and validation of perception pipelines.

ROS Parameters

ROS Parameter	Type	Default	Description
`msg_type`	`string`	`apriltag_msgs/msg/AprilTagDetectionArray`	Input message type for AprilTag detections.
`publish_rate`	`float`	`1.0`	Rate (Hz) at which statistics are published.
`save_to_file`	`bool`	`true`	Whether to save final statistics to a file on shutdown.
`log_folder`	`string`	`/tmp`	Directory where the statistics file will be saved.
`log_file_name`	`string`	`apriltag_stats_<pid>`	Name of the output statistics file.
`shutdown_timeout`	`float`	`5.0`	Timeout in seconds before shutdown if no messages are received.
`expected_tag_ids`	`list[int]`	`[-1]`	List of expected AprilTag IDs for evaluation (`-1` means any tag).
`rolling_window_frames`	`int`	`30`	Number of frames used for rolling-window statistics.

ROS Topics Subscribed

ROS Topic	Interface	Description
`apriltag_detections`	`apriltag_msgs/msg/AprilTagDetectionArray` / `isaac_ros_apriltag_interfaces/msg/AprilTagDetectionArray`	Input AprilTag detection messages.

ROS Topics Published

ROS Topic	Interface	Description
`apriltag_stats`	`std_msgs/msg/String`	JSON-formatted statistics with detection metrics.

Usage

# Run the AprilTag monitor node with custom parameters
$ ros2 run bp_varich_benchmark_experiments apriltag_monitor_node \
    --ros-args -p shutdown_timeout:=10.0 -p publish_rate:=1.0

AprilTag Visualizer Node

This ROS 2 node visualizes AprilTag detections on image frames and generates an annotated video output. It subscribes to synchronized image, camera info, and detection topics, overlays tag information such as IDs, corner positions, and pose axes, and publishes the annotated images.

The node also records the processed frames into an MP4 video file for offline analysis and visualization. It uses a dedicated visualization engine for rendering and video handling, and supports multiple detection message formats. The node is designed for both real-time monitoring and post-processing of perception pipeline outputs.

ROS Parameters

ROS Parameter	Type	Default	Description
`msg_type`	`string`	`apriltag_msgs/msg/AprilTagDetectionArray`	Input message type for AprilTag detections.
`log_folder`	`string`	`/tmp`	Directory where the output video file will be saved.
`log_file_name`	`string`	`apriltag_visualization_<pid>`	Name of the output video file (without extension).
`shutdown_timeout`	`float`	`5.0`	Timeout in seconds before shutdown if no messages are received.
`video_fps`	`float`	`30.0`	Frame rate of the output video.
`tag_size`	`float`	`1.0`	Physical size of the AprilTag in meters (used for pose visualization).
`axis_length`	`float`	`0.1`	Length of the drawn pose axes in meters.

ROS Topics Subscribed

ROS Topic	Interface	Description
`image`	`sensor_msgs/msg/Image`	Input image stream (BGR8 or RGB8).
`camera_info`	`sensor_msgs/msg/CameraInfo`	Camera intrinsic parameters used for pose visualization.
`apriltag_detections`	`apriltag_msgs/msg/AprilTagDetectionArray` / `isaac_ros_apriltag_interfaces/msg/AprilTagDetectionArray`	AprilTag detection messages.

ROS Topics Published

ROS Topic	Interface	Description
`annotated_image`	`sensor_msgs/msg/Image`	Output image with overlaid AprilTag detections and pose information.

Usage

# Run the AprilTag visualizer node with custom parameters
$ ros2 run bp_varich_benchmark_experiments apriltag_visualizer_node \
    --ros-args -p log_folder:=/tmp -p tag_size:=0.162

Segmentation Decoder Node

This ROS 2 node decodes segmentation outputs into mask images suitable for visualization or further processing. It supports both tensor-based outputs and pre-processed image inputs, making it flexible for integration with different inference pipelines. Depending on the selected decoding mode, the node applies either argmax (for multi-class segmentation) or thresholding (for binary segmentation) to generate the final mask.

The resulting segmentation mask is published as a mono8 encoded image, enabling compatibility with standard ROS 2 image processing and visualization tools.

ROS Parameters

ROS Parameter	Type	Default	Description
`msg_type`	`string`	`sensor_msgs/msg/Image`	Input message type (`isaac_ros_tensor_list_interfaces/msg/TensorList` or `sensor_msgs/msg/Image`).
`mode`	`string`	`argmax`	Decoding mode (`argmax` for multi-class, `threshold` for binary segmentation).
`threshold`	`float`	`0.0`	Threshold value used in binary segmentation mode.
`input_dtype`	`string`	`float32`	Data type of the input tensor or image.
`output_dtype`	`string`	`uint8`	Data type of the output mask image.

ROS Topics Subscribed

ROS Topic	Interface	Description
`input`	`TensorList` / `sensor_msgs/msg/Image`	Input segmentation data (raw tensor output or preprocessed image).

ROS Topics Published

ROS Topic	Interface	Description
`mask`	`sensor_msgs/msg/Image`	Decoded segmentation mask in `mono8` format.

Usage

# Run the segmentation decoder node with default parameters
$ ros2 run bp_varich_benchmark_experiments segmentation_decoder_node \
    --ros-args -p msg_type:=sensor_msgs/msg/Image -p mode:=argmax

ONNX Runtime Node

This ROS 2 node performs neural network inference using pre-trained ONNX models via the ONNX Runtime library. It subscribes to a tensor stream, executes the model, and publishes the inference results as output tensors. The node is designed to be flexible and backend-agnostic, supporting multiple execution providers including CPU, CUDA, and TensorRT, allowing it to adapt to different hardware acceleration environments.

ROS Parameters

ROS Parameter	Type	Default	Description
`model_file_path`	`string`	-	Path to the ONNX model file used for inference.
`input_binding_names`	`list[string]`	["input"]	List of input tensor names expected by the model.
`output_binding_names`	`list[string]`	["output"]	List of output tensor names produced by the model.
`backend`	`string`	["cpu"]	Execution backend used for inference (e.g., CPU, CUDA, TensorRT).

ROS Topics Subscribed

ROS Topic	Interface	Description
`tensor_pub`	`TensorList`	Input tensor list containing preprocessed data for model inference.

ROS Topics Published

ROS Topic	Interface	Description
`tensor_sub`	`TensorList`	Output tensor list containing inference results from the model.

Usage

# Run the ONNX Runtime node with specified model path
$ ros2 run bp_varich_benchmark_experiments onnx_runtime_node --ros-args -p model_path:=/path/to/model.onnx

Segmentation Monitor Node

This ROS 2 node monitors the quality of semantic segmentation results by analyzing RGB images and corresponding segmentation masks. It computes a range of metrics including temporal consistency, per-class occupancy, and blob connectivity using an internal metrics engine.

The node supports both full-history and rolling-window analysis, allowing flexible evaluation over time. It can automatically infer class mappings from mask values or use user-defined class mappings. Metrics are periodically published as JSON snapshots to a ROS topic for real-time monitoring, and a final report can be saved to disk upon shutdown.

ROS Parameters

ROS Parameter	Type	Default	Description
`publish_rate`	`float`	`1.0`	Rate (Hz) at which statistics are published.
`save_to_file`	`bool`	`true`	Whether to save final statistics to a file on shutdown.
`log_folder`	`string`	`/tmp`	Directory where the statistics file will be saved.
`log_file_name`	`string`	`segmentation_stats_<pid>`	Name of the output statistics file.
`shutdown_timeout`	`float`	`5.0`	Timeout in seconds before shutdown if no messages are received.
`expected_class_map`	`list[string]`	`[""]`	Optional mapping of class IDs to class names. If empty, classes are inferred automatically.
`ignore_classes`	`list[string]`	`[""]`	List of class names to exclude from metric computation.
`blob_small_threshold`	`int`	`50`	Minimum number of pixels for a blob to be considered valid.
`presence_min_pixels`	`int`	`1`	Minimum number of pixels required to consider a class present.
`window_size`	`int`	`-1`	Number of frames used for statistics (`-1` for full history, >0 for rolling window).

ROS Topics Subscribed

ROS Topic	Interface	Description
`image`	`sensor_msgs/msg/Image`	Input RGB image stream.
`mask`	`sensor_msgs/msg/Image`	Input segmentation mask (`mono8` / `mono16`).

ROS Topics Published

ROS Topic	Interface	Description
`segmentation_stats`	`std_msgs/msg/String`	JSON-formatted segmentation quality metrics.

Usage

# Run the segmentation monitor node with custom parameters
$ ros2 run bp_varich_benchmark_experiments segmentation_monitor_node \
    --ros-args -p shutdown_timeout:=10.0 -p publish_rate:=1.0

Segmentation Visualizer Node

This ROS 2 node visualizes segmentation masks on image frames and generates an annotated video output. It subscribes to RGB images and corresponding segmentation masks, overlays the masks using configurable opacity and color mapping, and publishes the resulting annotated images.

The node also records the processed frames into an MP4 video file for offline analysis and visualization. It leverages a dedicated visualization engine for rendering and video handling, and is suitable for both real-time monitoring and post-processing of segmentation results.

ROS Parameters

ROS Parameter	Type	Default	Description
`log_folder`	`string`	`/tmp`	Directory where the output video file will be saved.
`log_file_name`	`string`	`segmentation_visualization_<pid>`	Name of the output video file (without extension).
`shutdown_timeout`	`float`	`5.0`	Timeout in seconds before shutdown if no messages are received.
`video_fps`	`float`	`30.0`	Frame rate of the output video.
`mask_opacity`	`float`	`0.5`	Opacity of the segmentation mask overlay (0.0–1.0).
`colormap_type`	`string`	`jet`	Colormap used for mask visualization (OpenCV colormap name).

ROS Topics Subscribed

ROS Topic	Interface	Description
`image`	`sensor_msgs/msg/Image`	Input image stream (BGR8 or RGB8).
`mask`	`sensor_msgs/msg/Image`	Input segmentation mask (`mono8`, `mono16`, or `bgr8`).

ROS Topics Published

ROS Topic	Interface	Description
`annotated_image`	`sensor_msgs/msg/Image`	Output image with overlaid segmentation mask.

Usage

# Run the segmentation visualizer node with custom parameters
$ ros2 run bp_varich_benchmark_experiments segmentation_visualizer_node \
    --ros-args -p log_folder:=/tmp -p mask_opacity:=0.5

VSLAM Monitor Node

This ROS 2 node monitors Visual SLAM odometry and computes aggregated stability and performance statistics. It subscribes to nav_msgs/msg/Odometry messages and analyzes trajectory behavior, motion consistency, and data quality over time.

The node evaluates multiple metrics including frequency stability, trajectory length, velocity statistics, and anomaly detection such as jumps or invalid values. It is designed to assess the robustness of Visual SLAM pipelines without requiring ground truth data. Periodic JSON snapshots are published to a ROS topic, and a final report is generated upon shutdown.

ROS Parameters

ROS Parameter	Type	Default	Description
`msg_type`	`string`	`nav_msgs/msg/Odometry`	Input odometry message type.
`publish_rate`	`float`	`1.0`	Rate (Hz) at which statistics are published.
`save_to_file`	`bool`	`true`	Whether to save final statistics to a file on shutdown.
`log_folder`	`string`	`/tmp`	Directory where the statistics file will be saved.
`log_file_name`	`string`	`vslam_stats_<pid>`	Name of the output statistics file.
`shutdown_timeout`	`float`	`5.0`	Timeout in seconds before shutdown if no messages are received.
`step_outlier_threshold`	`float`	`0.5`	Threshold for detecting sudden position jumps (outliers).
`rolling_window_size`	`int`	`30`	Number of frames used for rolling-window analysis.
`threshold_nan_count`	`float`	`0.0`	Allowed number of NaN values before marking data as invalid.
`max_speed_threshold`	`float`	`5.0`	Maximum allowed speed before flagging anomaly.
`valid_message_rate_threshold`	`float`	`80.0`	Minimum valid message ratio (%) required for stable tracking.
`outlier_count_threshold`	`int`	`5`	Maximum number of allowed outliers before degradation is reported.

ROS Topics Subscribed

ROS Topic	Interface	Description
`odometry`	`nav_msgs/msg/Odometry`	Input Visual SLAM odometry stream (e.g., from Isaac ROS Visual SLAM).

ROS Topics Published

ROS Topic	Interface	Description
`vslam_stats`	`std_msgs/msg/String`	JSON-formatted Visual SLAM stability and performance metrics.

Usage

# Run the VSLAM monitor node with custom parameters
$ ros2 run bp_varich_benchmark_experiments vslam_monitor_node \
    --ros-args -p shutdown_timeout:=10.0 -p publish_rate:=1.0

VSLAM Visualizer Node

This ROS 2 node visualizes Visual SLAM odometry on image frames and generates an annotated video output. It subscribes to image, camera info, odometry, and optional point cloud topics, overlays trajectory and motion information (position, orientation, velocity), and publishes the resulting annotated images.

The node also records the processed frames into an MP4 video file for offline analysis. It uses a dedicated visualization engine for rendering and video generation, and supports synchronized multi-sensor inputs to ensure consistent frame-level visualization of SLAM behavior.

ROS Parameters

ROS Parameter	Type	Default	Description
`odometry_msg_type`	`string`	`nav_msgs/msg/Odometry`	Input odometry message type.
`pointcloud_msg_type`	`string`	`sensor_msgs/PointCloud2`	Input point cloud message type.
`log_folder`	`string`	`/tmp`	Directory where the output video file will be saved.
`log_file_name`	`string`	`vslam_visualization_<pid>`	Name of the output video file (without extension).
`shutdown_timeout`	`float`	`5.0`	Timeout in seconds before shutdown if no messages are received.
`video_fps`	`float`	`30.0`	Frame rate of the output video.

ROS Topics Subscribed

ROS Topic	Interface	Description
`image`	`sensor_msgs/msg/Image`	Input image stream (BGR8 or RGB8).
`camera_info`	`sensor_msgs/msg/CameraInfo`	Camera intrinsic parameters for projection and visualization.
`odometry`	`nav_msgs/msg/Odometry`	Visual SLAM odometry data (position, orientation, velocity).
`pointcloud`	`sensor_msgs/msg/PointCloud2`	Optional point cloud data for spatial context visualization.

ROS Topics Published

ROS Topic	Interface	Description
`annotated_image`	`sensor_msgs/msg/Image`	Output image with overlaid Visual SLAM trajectory and motion information.

Usage

# Run the VSLAM visualizer node with custom parameters
$ ros2 run bp_varich_benchmark_experiments vslam_visualizer_node \
    --ros-args -p log_folder:=/tmp

Pipeline Shutdown Node

This ROS 2 node monitors activity on a specified topic and gracefully shuts down the pipeline when inactivity is detected. It listens for incoming messages and tracks the time of the last received message. If no messages arrive within a configured timeout period, the node initiates a controlled shutdown procedure.

The shutdown process targets system processes that match user-defined patterns and terminates them progressively using signals (SIGINT → SIGTERM → SIGKILL). This ensures a safe and orderly shutdown of the pipeline, preventing resource leaks or corrupted states. The node supports different ROS 2 message types for the monitored topic, making it adaptable to various pipeline designs.

ROS Parameters

ROS Parameter	Type	Default	Description
`msg_type`	`string`	`std_msgs/msg/Empty`	ROS message type used for the monitored shutdown topic.
`shutdown_filter`	`list[string]`	`["component_container_mt.*"]`	List of process name patterns to match for shutdown.
`shutdown_timeout`	`float`	`5.0`	Time in seconds without messages before triggering shutdown.

ROS Topics Subscribed

ROS Topic	Interface	Description
`shutdown`	`std_msgs/msg/Empty` (or configurable)	Monitored topic used to track activity and trigger shutdown on inactivity.

ROS Topics Published

ROS Topic	Interface	Description
-	-	This node does not publish any topics.

Usage

# Run the pipeline shutdown node with a specified timeout
$ ros2 run bp_varich_benchmark_experiments pipeline_shutdown_node --ros-args -p shutdown_timeout:=10.0

Metrics

AprilTag Detection Metrics

The quality metrics are computed by a dedicated monitoring node designed for the AprilTag detection task. This node takes as input the results of the detection pipeline, computes quality-related metrics, and produces outputs in JSON format.

AprilTag Detection Metrics describe the performance, reliability, and accuracy of AprilTag detection during benchmark execution. They evaluate detection consistency across frames, tag distribution, timing behavior, robustness to detection dropouts, and overall detection quality.

Example Output

{
  "summary": {
    "total_frames": 33005,
    "total_detections": 33005,
    "unique_tags": 1,
    "overall_detection_rate_percent": 100.0
  },
  "metrics": {
    "detection": {
      "total_detections": 33005,
      "frames_processed": 33005,
      "frames_with_detections": 33005,
      "detection_rate_percent": 100.0,
      "avg_detections_per_frame": 1.0,
      "max_detections_in_frame": 1,
      "p95_detections_per_frame": 1
    },
    "tags": {
      "unique_tag_count": 1,
      "per_tag_counts": {
        "16": 33005
      },
      "per_tag_presence_percent": {
        "16": 100.0
      }
    },
    "performance": {
      "avg_frame_interval_ms": 6.422,
      "max_frame_interval_ms": 12584.178,
      "p95_frame_interval_ms": 6.415
    },
    "dropouts": {
      "rolling_frames": 30,
      "rolling_detection_rate_percent": 100.0,
      "rolling_avg_detections_per_frame": 1.0,
      "current_dropout_streak_frames": 0,
      "max_dropout_streak_frames": 0
    },
    "accuracy": {
      "true_positives": 1,
      "false_positives": 0,
      "false_negatives": 0,
      "precision": 1.0,
      "recall": 1.0,
      "f1_score": 1.0
    }
  },
  "frame_level_data": {
    "detections_per_frame": [
      1,
      1,
      1,
      ... 
    ],
    "frame_intervals_ms": [
      33.649186,
      33.435573,
      33.670306,
      ... 
    ]
  },
  "metadata": {
    "node": "apriltag_monitor_node",
    "test_start_time": "2026-04-23T20:53:54Z",
    "uptime_seconds": 217.82938427,
    "test_end_time": "2026-04-23T20:57:32Z",
    "expected_tag_ids": [
      16
    ],
    "final_snapshot": true
  }
}

total_frames indicates the total number of processed frames. total_detections represents the total number of detected tags across all frames. unique_tags indicates the number of unique detected tag IDs. overall_detection_rate_percent represents the percentage of frames in which at least one tag was detected, reflecting overall detection coverage.

total_detections represents the total number of detections across all frames. frames_processed indicates the total number of processed frames. frames_with_detections indicates how many frames contained at least one detection. detection_rate_percent represents the percentage of frames with detections. avg_detections_per_frame indicates the average number of detections per frame. max_detections_in_frame represents the maximum number of detections observed in a single frame. p95_detections_per_frame indicates the 95th percentile of detections per frame, reflecting typical upper-bound behavior.

unique_tag_count indicates the number of unique detected tag IDs. per_tag_counts represents the number of detections for each tag ID. per_tag_presence_percent represents the percentage of frames in which each tag was detected. These metrics allow analyzing detection consistency and coverage for individual tags.

avg_frame_interval_ms represents the average time interval between consecutive frames. max_frame_interval_ms indicates the maximum observed interval, which may reveal significant delays or dropped frames. p95_frame_interval_ms represents the 95th percentile of frame intervals, reflecting typical system performance while excluding extreme outliers.

rolling_frames defines the size of the sliding window used for analysis. rolling_detection_rate_percent represents the percentage of frames with detections within the window. rolling_avg_detections_per_frame indicates the average number of detections per frame within the window. current_dropout_streak_frames represents the current number of consecutive frames without detections. max_dropout_streak_frames indicates the maximum observed sequence of frames without detections, reflecting robustness of the detection pipeline.

true_positives represents correctly detected expected tags. false_positives indicates detections of unexpected tags. false_negatives represents expected tags that were not detected. precision measures the proportion of correct detections among all detections. recall measures the proportion of expected tags that were successfully detected. f1_score represents the harmonic mean of precision and recall, providing an overall measure of detection accuracy.

detections_per_frame represents the number of detected tags for each frame, allowing analysis of detection consistency over time. detection_intervals_ms represents the time intervals between consecutive frames in milliseconds. These metrics enable detailed investigation of temporal patterns, performance fluctuations, and potential anomalies in the detection process.

metadata provides auxiliary information about the test and the node that generated the metrics. node specifies the name of the ROS 2 node responsible for monitoring and metric calculation. test_start_time and test_end_time are ISO 8601 timestamps marking the beginning and end of the test, allowing precise determination of the experiment duration. uptime_seconds indicates the total runtime of the node in seconds, reflecting the period over which data was collected. expected_tag_ids lists the AprilTag IDs that were expected during evaluation, enabling targeted analysis of detection performance. final_snapshot is a boolean flag indicating whether this report represents the final state of the system at the end of the test. These fields enable identification of the data source, tracking of experiment parameters, and ensure reproducibility of results.

Segmentation Quality Metrics

The quality metrics are computed by a dedicated monitoring node designed for the semantic segmentation task. This node takes as input the results of the segmentation pipeline, computes quality-related metrics, and produces outputs in JSON format.

Segmentation Quality Metrics describe the quality and temporal behavior of neural network outputs during the benchmark run. These metrics evaluate segmentation stability, spatial distribution of detected classes, structural consistency of predicted masks, and overall presence of objects across frames.

Example Output

{
  "temporal": {
    "frames_processed": 8010,
    "occupancy_aggregate": {
      "min": 0.076,
      "avg": 0.134,
      "max": 0.165
    },
    "delta_aggregate": {
      "min": 0.0,
      "avg": 0.034,
      "max": 0.088
    },
    "instability": 0.028
  },
  "occupancy": {
    "person": {
      "min": 0.076,
      "avg": 0.134,
      "max": 0.165
    }
  },
  "blob_analysis": {
    "person": {
      "num_components": {
        "min": 2,
        "avg": 2.6,
        "max": 4
      },
      "largest_blob_ratio": {
        "min": 0.385,
        "avg": 0.549,
        "max": 0.78
      },
      "noise_ratio": {
        "min": 0.0,
        "avg": 0.008,
        "max": 0.041
      }
    }
  },
  "class_statistics": {
    "background": {
      "frames_detected": 8010,
      "presence_percent": 100.0
    },
    "person": {
      "frames_detected": 8010,
      "presence_percent": 100.0
    }
  },
  "metadata": {
    "node": "segmentation_monitor_node",
    "test_start_time": "2026-04-22T19:20:42Z",
    "uptime_seconds": 216.751184368,
    "test_end_time": "2026-04-22T19:24:19Z",
    "expected_class_map": {
      "0": "background",
      "1": "person"
    },
    "ignore_classes": [
      "background"
    ],
    "blob_small_threshold": 1000,
    "presence_min_pixels": 1,
    "window_size": -1,
    "final_snapshot": true
  }
}

frames_processed indicates the total number of frames processed during the test. occupancy_aggregate represents the proportion of pixels occupied by the target class across all frames, where min, avg, and max correspond to the minimum, average, and maximum occupancy values. delta_aggregate describes frame-to-frame changes in occupancy, where min, avg, and max reflect the stability of segmentation between consecutive frames. instability is the standard deviation of these changes, indicating overall temporal consistency of the model output, where lower values correspond to more stable predictions.

num_components represents the number of connected regions detected for a given class, where min, avg, and max indicate the variability in object count across frames. largest_blob_ratio describes the proportion of pixels belonging to the largest connected component relative to all pixels of the class, reflecting how dominant a single object is within the scene. noise_ratio represents the fraction of pixels belonging to small isolated components (below a predefined size threshold), indicating the level of segmentation noise and artifacts.

frames_detected indicates the number of frames in which the class was present, while presence_percent represents the percentage of frames where the class was detected relative to the total number of processed frames. These metrics provide a measure of detection consistency and completeness over time.

metadata provides auxiliary information about the test and the node that generated the metrics. node specifies the name of the ROS 2 node responsible for monitoring and metric calculation. test_start_time and test_end_time are ISO 8601 timestamps marking the beginning and end of the test, allowing precise determination of the experiment duration. uptime_seconds indicates the total runtime of the node in seconds, reflecting the period over which data was collected. expected_class_map defines the mapping between class IDs and class names used for evaluation, while ignore_classes lists the classes excluded from metric computation. blob_small_threshold and presence_min_pixels specify thresholds for blob analysis and class presence, respectively. window_size determines the number of frames used for statistics calculation (with -1 indicating full-history analysis). final_snapshot is a boolean flag indicating whether this report represents the final state of the system at the end of the test. These fields enable identification of the data source, tracking of experiment parameters, and ensure reproducibility of results.

Visual SLAM Stability Metrics

The quality metrics are computed by a dedicated monitoring node designed for the Visual SLAM task. This node takes as input the odometry output of the SLAM pipeline, computes stability and performance-related metrics, and produces results in JSON format.

Visual SLAM Stability Metrics describe the behavior, stability, and reliability of visual SLAM during the benchmark run. These metrics evaluate timing consistency of odometry messages, trajectory characteristics, motion dynamics, data integrity, and overall system health.

Example Output

{
  "metadata": {
    "node": "vslam_monitor_node",
    "test_end_time": "2026-04-22T17:09:44Z",
    "uptime_seconds": 196.49,
    "test_start_time": "2026-04-22T17:06:27Z",
    "final_snapshot": true
  },
  "metrics": {
    "frequency": {
      "mean_dt_sec": 0.0334,
      "max_dt_sec": 5.4909,
      "messages_processed": 6839
    },
    "trajectory": {
      "total_length_m": 298.604,
      "mean_step_m": 0.0449
    },
    "position": {
      "max_step_m": 0.238,
      "outlier_count": 0,
      "outlier_threshold_m": 0.5
    },
    "velocity": {
      "mean_speed_m_s": 0.769,
      "max_speed_m_s": 0.961
    },
    "quality": {
      "nan_count": 514,
      "valid_message_rate": 92.48
    }
  },
  "health": {
    "status": "HEALTHY",
    "explanation": "SLAM tracking is stable and continuous"
  }
}

mean_dt_sec represents the average time interval between consecutive odometry messages, indicating the effective message frequency. max_dt_sec reflects the maximum observed interval between messages, which may indicate delays or dropped messages if significantly higher than the mean. messages_processed indicates the total number of odometry messages processed during the test.

total_length_m represents the total accumulated trajectory length in meters, reflecting the overall distance traveled during the test. mean_step_m indicates the average distance between consecutive poses, providing insight into motion resolution and consistency of updates.

max_step_m represents the maximum distance between two consecutive positions, indicating the largest observed motion step. outlier_count indicates the number of position jumps exceeding a predefined threshold, representing potential tracking failures or instability. outlier_threshold_m defines the threshold used to classify a step as an outlier. The absence of outliers indicates stable and consistent tracking.

mean_speed_m_s represents the average speed of the system over time, while max_speed_m_s indicates the maximum observed speed. These values are derived from the magnitude of the linear velocity vector. Large deviations between mean and maximum speed may indicate noise or instability in velocity estimation.

nan_count indicates the number of messages containing invalid values such as NaN or infinity in position or velocity fields. valid_message_rate represents the percentage of valid messages relative to the total number of processed messages. Higher values indicate better data quality and more reliable SLAM performance.

status represents the overall system condition, which can be HEALTHY, DEGRADED, or FAILED. explanation provides a human-readable description of the system state. The status is determined based on thresholds applied to trajectory stability, velocity, data quality, and presence of outliers, providing a high-level evaluation of SLAM reliability and robustness.

Visualization

AprilTag Visualization

This visualization shows detected AprilTags overlaid on the input image stream. It includes tag IDs, corner positions, and pose axes, allowing visual validation of detection accuracy and stability.

Example Output

Segmentation Visualization

This visualization overlays semantic segmentation masks onto RGB image frames. It supports configurable colormaps and opacity blending, enabling clear interpretation of class-level scene understanding.

Example Output

The dataset r2b_hallway from the NVIDIA R2B Dataset 2023 is being visualized.

Visual SLAM Visualization

This visualization displays Visual SLAM odometry directly on image frames, including trajectory information, camera motion, and optionally point cloud context. It is useful for analyzing tracking stability and motion consistency.

Example Output

The dataset r2b_cafe from the NVIDIA R2B Dataset 2023 is being visualized.

Tools

System Information Collector

This script collects hardware and software information about the execution environment to ensure reproducibility and traceability of benchmark experiments. It gathers key system details such as CPU and GPU models, system architecture, operating system, NVIDIA driver version, CUDA version, Python version, ROS 2 distribution, and Isaac ROS release.

The collected information is saved as a JSON file and can be stored alongside benchmark results to document the system configuration used during experiments.

Parameters

Parameter	Type	Default	Required	Description
`-o, --output`	`Path`	`system_info.json`	No	Path to the output JSON file where system information will be saved.

Usage

# Collect system information and save to JSON file
$ ros2 run collect_system_info.py -o ~/system_info.json

TensorRT Engine Builder

This script provides a command-line interface for building optimized TensorRT engine files from ONNX models using the trtexec tool. It enables flexible configuration of engine generation, including precision modes (FP32, FP16, INT8, AUTO), dynamic input shapes, and advanced optimization settings.

The builder supports INT8 quantization with calibration, dynamic shape profiles, and hardware acceleration via DLA (on supported platforms such as Jetson). It also exposes low-level performance tuning parameters such as workspace size, timing iterations, and kernel selection behavior. The resulting engine is optimized for inference performance and can be used in downstream ROS 2 pipelines.

Parameters

Parameter	Type	Default	Required	Description
`--onnx`	`Path`	-	Yes	Absolute path to the input ONNX model file.
`--engine`	`Path`	-	Yes	Absolute path where the TensorRT engine will be saved.
`--fp32`	`flag`	`true`	No	Use FP32 precision (default mode).
`--fp16`	`flag`	`false`	No	Enable FP16 precision (faster, reduced precision).
`--int8`	`flag`	`false`	No	Enable INT8 precision (requires calibration file).
`--best`	`flag`	`false`	No	Automatically select the best precision mode.
`--calib`	`Path`	-	No	Path to calibration cache file for INT8 quantization.
`--percentile`	`float`	`99.9`	No	Percentile used for INT8 calibration.
`--shapes`	`str`	-	No	Static input shape (e.g., `input:1x3x640x640`).
`--minShapes`	`str`	-	No	Minimum input shape for dynamic profiles.
`--optShapes`	`str`	-	No	Optimal input shape for dynamic profiles.
`--maxShapes`	`str`	-	No	Maximum input shape for dynamic profiles.
`--maxBatch`	`int`	-	No	Maximum batch size.
`--dynamicShapes`	`flag`	`false`	No	Enable dynamic shape support.
`--workspace`	`int`	auto	No	Workspace size in MiB for optimization.
`--skip-inference`	`flag`	`false`	No	Skip inference testing during engine build.
`--allowGPUFallback`	`flag`	`false`	No	Allow GPU fallback for unsupported DLA operations.
`--timeoutMs`	`int`	-	No	Timeout in milliseconds for kernel selection.
`--minTiming`	`int`	-	No	Minimum number of timing iterations.
`--avgTiming`	`int`	-	No	Number of averaging iterations.
`--useDLACore`	`int`	-	No	Use DLA core (Jetson only), specify core index.
`--profilingVerbosity`	`str`	`default`	No	Profiling verbosity level (`quiet`, `default`, `detailed`, `verbose`).
`--trtexec`	`Path`	`trtexec`	No	Path to `trtexec` binary.
`--force`	`flag`	`false`	No	Rebuild engine even if it already exists.
`--extra-arg`	`list[str]`	`[]`	No	Additional arguments passed directly to `trtexec`.

Usage

# Basic FP16 build
ros2 run bp_varich_benchmark_experiments create_trt_engine \
    --onnx /path/to/model.onnx \
    --engine /path/to/model.engine \
    --fp16
    -- skip-inference

# INT8 quantized (requires calibration file)
ros2 run bp_varich_benchmark_experiments create_trt_engine \
    --onnx /path/to/model.onnx \
    --engine /path/to/model_int8.engine \
    --int8 --calib /path/to/calibration.cache

Manifest Generator

This script generates a manifest.json file that contains metadata and configuration parameters for benchmark experiment execution. It is designed to standardize experiment descriptions by combining a base YAML configuration with additional runtime parameters provided via the command line.

The generator supports loading an optional YAML configuration file as a base template and merging it with user-defined key=value parameters passed through CLI arguments. During execution, it automatically enriches the manifest with metadata such as generation timestamp and manifest version, ensuring reproducibility and traceability of benchmark runs.

Parameters

Parameter	Type	Default	Required	Description
`--output-dir`	`Path`	`.`	No	Directory where the `manifest.json` file will be saved.
`--output`	`str`	`manifest.json`	No	Name of the output manifest file.
`--param`	`list[key=value]`	`[]`	No	Configuration parameter in `key=value` format. Can be specified multiple times to override or extend configuration values.
`--config`	`Path`	-	No	Path to a YAML configuration file used as the base configuration.
`-v, --verbose`	`flag`	`false`	No	Enables verbose logging with detailed execution output.

Usage

# Generate manifest with parameters from command line
$ ros2 run generate_manifest.py --output-dir ./results --param package=isaac_ros_tensor_rt --param model=resnet50

# Generate manifest by loading base parameters from YAML config file
$ ros2 run generate_manifest.py --output-dir ./results --config base_config.yaml --param mode=graph

Contacts

For questions, suggestions, or collaboration, please contact:

Author: Dmytro Varich
Email: dmytro.varich@student.tuke.sk
GitHub: dmytro-varich

License

This project is licensed under the MIT License. See the LICENSE file for details.

Downloads last month: 77

Total file size:

35.8 MB

BP-Varich Benchmark Experiments

Contents

Getting Started

Core Components

Benchmark Entry Point

Pipeline Entry Point

Configuration

ROS 2 Nodes

AprilTag Monitor Node

ROS Parameters

ROS Topics Subscribed

ROS Topics Published

Usage

AprilTag Visualizer Node

ROS Parameters

ROS Topics Subscribed

ROS Topics Published

Usage

Segmentation Decoder Node

ROS Parameters

ROS Topics Subscribed

ROS Topics Published

Usage

ONNX Runtime Node

ROS Parameters

ROS Topics Subscribed

ROS Topics Published

Usage

Segmentation Monitor Node

ROS Parameters

ROS Topics Subscribed

ROS Topics Published

Usage

Segmentation Visualizer Node

ROS Parameters

ROS Topics Subscribed

ROS Topics Published

Usage

VSLAM Monitor Node

ROS Parameters

ROS Topics Subscribed

ROS Topics Published

Usage

VSLAM Visualizer Node

ROS Parameters

ROS Topics Subscribed

ROS Topics Published

Usage

Pipeline Shutdown Node

ROS Parameters

ROS Topics Subscribed

ROS Topics Published

Usage

Metrics

AprilTag Detection Metrics

Example Output

Segmentation Quality Metrics

Example Output

Visual SLAM Stability Metrics

Example Output

Visualization

AprilTag Visualization

Segmentation Visualization

Visual SLAM Visualization

Tools

System Information Collector

Parameters

Usage

TensorRT Engine Builder

Parameters

Usage

Manifest Generator

Parameters

Usage

Contacts

License