Library to match objects to lanelets

Example maps in the lanelet2-format

Parser/Writer module for lanelet2

Examples for working with Lanelet2

Lanelet2 core module

Meta-package for lanelet2

Primer on Particle Filtering with Beluga.

Set of miscellaneous tools to work with beluga.

System tests for beluga.

Utilities to interface ROS with Beluga.

Example launch files for Beluga AMCL.

Scripts to benchmark, profile and compare beluga with other AMCL implementations.

An AMCL node implementation for ROS2 using Beluga.

A generic MCL library for ROS2.

Tile map provides a slippy map style interface for visualizing OpenStreetMap and GoogleMap tiles. A mapviz visualization plug-in is also implemented

The swri_transform_util package contains utility functions and classes for transforming between coordinate frames.

A package with commonly used system utilities.

Contains nodes and utilities for serial communication in ROS.

This library provides functionality to simplify working with the navigation messages defined in marti_nav_msgs.

A package that extends rclcpp with some commonly used functionality to reduce boilerplate code.

A package with commonly used OpenCV functionality.

A package with commonly used math utility code.

A package of commonly image manipulation utilities.

Commonly used geometry routines, implemented in a ROS friendly package.

This package provides documentation on common interface conventions for drive-by-wire systems.

Utility functions for interacting with console

A rosout GUI viewer developed at Southwest Research Institute as an alternative to rqt_console.

Command line tools for introspecting ROS systems

ROS 1 and 2 driver for SICK scanner

multires_image

mavros_msgs defines messages for

Extra nodes and plugins for

MAVROS -- MAVLink extendable communication node for ROS with proxy for Ground Control Station.

marti_visualization_msgs

marti_status_msgs

marti_sensor_msgs

marti_perception_msgs

marti_nav_msgs

marti_introspection_msgs

marti_dbw_msgs

marti_common_msgs

marti_can_msgs

Common plugins for the Mapviz visualization tool

ROS interfaces used by Mapviz

mapviz

MAVLink communication library. This library provide unified connection handling classes and URL to connection object mapper. This library can be used in standalone programs.

connects to a GPSd server and broadcasts GPS fixes using the NavSatFix message

gps_umd metapackage

GPS routines for use in GPS drivers

GPS messages for use in GPS drivers

Simple library for using the `rclpy/rclcpp` action libraries

Example and configuration files for Gazebo simulation of UR manipulators.

A set of plugins for displaying occupancy information decoded from binary octomap messages.

ROS2 driver for the Robotiq gripper.

ROS2 driver package for the Robotiq gripper.

URDF and xacro description package for the Robotiq gripper.

Controllers for the Robotiq gripper.

Parser for Semantic Robot Description Format (SRDF).

ROS driver package for communication with the SBG navigation systems.

Messages, services and actions used by MoveIt

Foonathan/memory vendor package for Fast-RTPS.

GenICam/GigE Vision Convenience Layer. This package combines the Roboception convenience layer for images with the GenICam reference implementation and a GigE Vision transport layer. It is a self contained package that permits configuration and image streaming of GenICam / GigE Vision 2.0 compatible cameras like the Roboception rc_visard. This package also provides some tools that can be called from the command line for discovering cameras, changing their configuration and streaming images. Although the tools are meant to be useful when working in a shell or in a script, their main purpose is to serve as example on how to use the API for reading and setting parameters, streaming and synchronizing images. See LICENSE.md for licensing terms of the different parts.

This library contains wrappers for generating floating point values, integers, quaternions using boost libraries. The constructor of the wrapper is guaranteed to be thread safe and initialize its random number generator to a random seed. Seeds are obtained using a separate and different random number generator.

Path planning and navigation algorithms for robots/vehicles moving on planar environments. This library builds upon mrpt-nav and the theory behind PTGs to generate libraries of "motion primitives" for vehicles with arbitrary shape and realistic kinematics and dynamics.

Helper functions for displaying and debugging MoveIt data in Rviz via published markers

PR2 Resources used for MoveIt! testing

panda Resources used for MoveIt testing

Fanuc Resources used for MoveIt testing

Resources used for MoveIt testing

AprilTag detector library

Implementation of warehouse_ros for sqlite

Python binding tools for C++

Wrapper around openeb

ROS messages for MRPT classes and objects

Launch files for common URDF operations

ROS Support Library

YAML helper library common to MOLA modules

GUI for MOLA

CLI tools to manipulate trajectory files as a complement to the evo package

C++ library with algorithms for relocalization, global localization, or pose estimation given a large initial uncertainty

C++ library for searchable pose lists

SE(3) pose and twist path data fusion estimator

SE(3) pose and twist path data fusion estimator

ROS message, services, and actions used in other MOLA packages.

Advanced metric map classes, using the generic `mrpt::maps::CMetricMap` interface, for use in other MOLA odometry and SLAM modules.

Launcher app for MOLA systems

Fundamental C++ virtual interfaces and data types for the rest of MOLA modules

Offline RawDataSource from rosbag2 datasets

Offline RawDataSource from MRPT rawlog datasets

Offline RawDataSource from Paris LUCO (CT-ICP) odometry/SLAM datasets

Offline RawDataSource from MulRan datasets

Offline RawDataSource from Kitti odometry/SLAM datasets

Offline RawDataSource from Kitti-360 datasets

Offline RawDataSource from EUROC SLAM datasets

Integrator of IMU angular velocity readings

Demo and example launch files for MOLA

Bidirectional bridge ROS2-MOLA

Metapackage with all core open-sourced MOLA packages.

CLI tool to evaluate the KITTI odometry bechmark metrics to trajectory files

rqt GUI plugin to visualize dot graphs.

ROS2 Navigation Stack

A handful of useful utility functions for nav_2d packages.

Basic message types for two dimensional navigation, extending from geometry_msgs::Pose2D.

A waypoint follower navigation server

voxel_grid provides an implementation of an efficient 3D voxel grid. The occupancy grid can support 3 different representations for the state of a cell: marked, free, or unknown. Due to the underlying implementation relying on bitwise and and or integer operations, the voxel grid only supports 16 different levels per voxel column. However, this limitation yields raytracing and cell marking performance in the grid comparable to standard 2D structures making it quite fast compared to most 3D structures.

Nav2's Output velocity smoother

TODO

Theta* Global Planning Plugin

TODO

Smoother action interface

Smac global planning plugin: A*, Hybrid-A*, State Lattice

An importable library for writing mobile robot applications in python3

Navigation 2 plugins for rviz

Rotation Shim Controller

Regulated Pure Pursuit Controller

TODO

TODO

Messages and service files for the Nav2 stack

nav2_mppi_controller

Refactored map server for ROS2 Navigation

A controller/manager for the lifecycle nodes of the Navigation 2 system

ROS2 controller (DWB) metapackage

This package provides an implementation of a 2D costmap that takes in sensor data from the world, builds a 2D or 3D occupancy grid of the data (depending on whether a voxel based implementation is used), and inflates costs in a 2D costmap based on the occupancy grid and a user specified inflation radius. This package also provides support for map_server based initialization of a costmap, rolling window based costmaps, and parameter based subscription to and configuration of sensor topics.

A set of headers for plugins core to the Nav2 stack

Controller action interface

Ceres constrained smoother

Common support functionality used throughout the navigation 2 stack

Collision Monitor

TODO

Bringup scripts and configurations for the Nav2 stack

TODO

TODO

Standard implementations of the GoalChecker and TrajectoryGenerators for dwb_core

Message/Service definitions specifically for the dwb_core

The dwb_critics package

TODO

The costmap_queue package

RVIZ plugin for IMU visualization

Various tools for IMU devices

Filter which fuses angular velocities, accelerations, and (optionally) magnetic readings from a generic IMU device into an orientation. Based on code by Sebastian Madgwick, http://www.x-io.co.uk/node/8#open_source_ahrs_and_imu_algorithms.

Filter which fuses angular velocities, accelerations, and (optionally) magnetic readings from a generic IMU device into a quaternion to represent the orientation of the device wrt the global frame. Based on the algorithm by Roberto G. Valenti etal. described in the paper "Keeping a Good Attitude: A Quaternion-Based Orientation Filter for IMUs and MARGs" available at http://www.mdpi.com/1424-8220/15/8/19302 .

Inverse Kinematics solver for MoveIt

Instantaneous Motion Generation for Robots and Machines.

Messages for describing objects and how to grasp them.

Messages for SocketCAN

Simple wrapper around SocketCAN

ROS-2 navigation bringup packages for neobotix robots

ROS2 Driver for the SICK safetyscanners

Python API for point_cloud_transport

Support for transporting PointCloud2 messages in compressed format and plugin interface for implementing additional PointCloud2 transports.

A ROS1 publisher to use with performance_test

ROS1 versions of performance_test messages to use when testing with a ROS1 bridge

Tool to test performance of ROS2 and DDS data layers and communication.

Apex.AI performance_test runner, plotter, and reporter

The smach_ros package contains extensions for the SMACH library to integrate it tightly with ROS. For example, SMACH-ROS can call ROS services, listen to ROS topics, and integrate with

this package contains a set of messages that are used by the introspection interfaces for smach.

SMACH is a task-level architecture for rapidly creating complex robot behavior. At its core, SMACH is a ROS-independent Python library to build hierarchical state machines. SMACH is a new library that takes advantage of very old concepts in order to quickly create robust robot behavior with maintainable and modular code.

This metapackage depends on the SMACH library and ROS SMACH integration packages.

CMake Functions and Modules for automating CMake

Custom messages for s_graphs

Package containing various utility types and functions for C

A set of 2D geometry classes modeled after the 3D geometry classes in tf2.

libpointmatcher is a modular ICP library, useful for robotics and computer vision.

Utilities for working with polygons, including triangulation

RViz visualizations for polygons

General purpose two-dimensional polygons. Formerly a part of nav_2d_msgs

Demo of polygon_rviz_plugins

Converts a 3D Point Cloud into a 2D laser scan. This is useful for making devices like the Kinect appear like a laser scanner for 2D-based algorithms (e.g. laser-based SLAM).

Provides nonlinear state estimation through sensor fusion of an abritrary number of sensors.

Generic joystick teleop for twist robots.

Package to parse NMEA strings and publish a very simple GPS message. Does not require or use the GPSD deamon.

Universal Robot ROS2 interface for Webots.

TurtleBot3 Burger robot ROS2 interface for Webots.

TIAGo robots ROS2 interface for Webots.

System tests for `webots_ros2` packages.

Tesla ROS2 interface for Webots.

Services and Messages of the webots_ros2 packages.

Mavic 2 Pro robot ROS2 interface for Webots.

This package allows to convert URDF and XACRO files into Webots PROTO files.

E-puck2 driver for Webots simulated robot

Implementation of the Webots - ROS 2 interface

ros2_control plugin for Webots

Interface between Webots and ROS2

Interfaces for motion_capture_tracking package.

ROS Package for different motion capture systems, including custom rigid body tracking support

Interface for using ROS with the

Utilities to interface with

Robot-independent Gazebo plugins for sensors, motors and dynamic reconfigurable components.

Message and service data structures for interacting with Gazebo from ROS2.

Provides a cmake config for the default version of Gazebo for the ROS distribution.

The CMake API for ament_black to lint Python code using black.

The ability to check code against style conventions using black and generate xUnit test result files.

Utility functions for displaying and debugging data in Rviz via published markers

RealSense description package for Intel 3D D400 cameras

RealSense camera_msgs package containing realsense camera messages definitions

RealSense camera package allowing access to Intel D400 3D cameras