VAMP MoveIt Planner Plugin Prototype

This package is a prototype MoveIt 2 planning pipeline plugin that calls the VAMP RRTC planner directly.

The plugin is useful if you want to see how to:

• expose VAMP as a MoveIt planning_interface::PlannerManager
• read a MoveIt MotionPlanRequest
• convert joint-space VAMP paths back into MoveIt trajectories
• build a VAMP collision environment from a sensor_msgs/msg/PointCloud2
• optionally provide a service for checking a remaining trajectory with VAMP

It is not a complete, general-purpose MoveIt/VAMP bridge.

Important Limitations

This plugin does not convert arbitrary MoveIt PlanningScene world geometry into VAMP. In particular, it does not translate MoveIt collision objects, attached collision objects, or octomap world geometry into VAMP primitives.

The environment representation is lower-level:

• current robot state from MoveIt/joint states
• goal constraints from the MoveIt MotionPlanRequest
• a point-cloud-derived VAMP CAPT collision structure

The VAMP robot model is also a compile-time C++ type. By default this package is configured for:

• header: vamp/robots/a200_1044.hh
• type: vamp::robots::a200_1044

For another robot, generate the VAMP robot header first, then rebuild this plugin with the matching CMake options.

Repository Status

This is intended as a reference/prototype package, not a polished drop-in planner. This repository is released under the MIT License.

Dependencies

• ROS 2
• MoveIt 2
• VAMP source tree, built locally
• a generated VAMP robot header for your robot

The package expects VAMP as a source dependency rather than an installed CMake package. By default it looks for VAMP at ../vamp relative to this package.

Build

Example workspace layout:

ros2_ws/
  src/
    vamp/
    vamp_moveit_planner_plugin/

Build VAMP first:

cd ros2_ws/src/vamp
cmake -B build -DCMAKE_BUILD_TYPE=Release .
cmake --build build

Then build this package:

cd ros2_ws
colcon build --symlink-install --packages-select vamp_moveit_planner_plugin \
  --cmake-args \
    -DCMAKE_BUILD_TYPE=Release \
    -DVAMP_ROOT=$PWD/src/vamp \
    -DVAMP_BUILD_DIR=$PWD/src/vamp/build \
    -DVAMP_ROBOT_HEADER=vamp/robots/a200_1044.hh \
    -DVAMP_ROBOT_TYPE=vamp::robots::a200_1044

Replace VAMP_ROBOT_HEADER and VAMP_ROBOT_TYPE for your generated robot.

MoveIt Configuration

Add the plugin as a planning pipeline:

planning_pipelines:
  - vamp
default_planning_pipeline: vamp

vamp:
  planning_plugin: vamp_moveit_planner_plugin/VampPlannerManager
  request_adapters: ""
  response_adapters: ""

  planning_group: manipulator
  joint_state_topic: /joint_states
  point_cloud_topic: /points
  target_frame: base_link

  point_radius: 0.06
  self_filter_point_cloud: true
  wait_for_environment: true
  publish_filtered_cloud: false
  filtered_point_cloud_topic: /points_vamp_filtered

  collision_check_service_name: check_trajectory_collision
  collision_check_skip_waypoints: 20

The same example is available at config/vamp_planning_pipeline.yaml.

Parameters

planning_group: MoveIt planning group whose active variables match the compiled VAMP robot dimension.

joint_state_topic: joint states used for point-cloud self-filtering.

point_cloud_topic: point cloud used to build the VAMP collision environment.

target_frame: frame used for VAMP collision points. Incoming point clouds are transformed into this frame with TF.

point_radius: radius assigned to point-cloud points when building CAPT.

self_filter_point_cloud: when true, removes points that collide with the current VAMP robot spheres before building CAPT.

wait_for_environment: when true, planning waits until at least one point cloud has been processed.

publish_filtered_cloud: when true, publishes the filtered cloud for debugging.

collision_check_service_name: service name for checking an already-generated trajectory against the latest VAMP environment.

collision_check_skip_waypoints: number of initial waypoints to skip during the trajectory collision check. This can avoid false positives near the robot's current self-filtered state.

Architecture

The plugin receives the standard MoveIt planning request through getPlanningContext(). The PlanningScene is used for robot state, goal constraints, robot model access, IK through MoveIt, and trajectory response plumbing.

Collision checking for planning is handled by VAMP using a CAPT built from the latest point cloud. This is intentionally separate from MoveIt's collision world.

For pose goals, the plugin asks MoveIt for IK using the kinematics solver configured for the planning group. For joint goals, it uses the joint constraints directly.

Adapting To A New Robot

1. Generate a spherized URDF for your robot with the VAMP/CoMMALab tooling.
2. Compile the spherized model into a VAMP robot header.
3. Make sure the MoveIt planning group has the same variable order/dimension as the generated VAMP robot type.
4. Build this package with VAMP_ROBOT_HEADER and VAMP_ROBOT_TYPE set to your generated robot.
5. Set planning_group, joint_state_topic, point_cloud_topic, and target_frame for your robot.

Known Gaps

• no full PlanningScene world conversion
• no runtime VAMP robot type selection
• limited goal constraint support
• no planner settings exposed beyond the basic environment parameters
• no automated tests yet

Authors

• Anil Zeybek

Affiliations

• Chair of Robotics, Artificial Intelligence and Real-time Systems
• Computing in Civil and Building Engineering
• TUM Georg Nemetschek Institute
• Technical University of Munich (TUM)

Acknowledgements

This work was carried out with the guidance and support of:

• Panagiotis Petropoulakis
• Prof. Dr.-Ing. André Borrmann
• Prof. Dr.-Ing. habil. Alois Christian Knoll

Citation

This plugin builds on the VAMP (Vector-Accelerated Motion Planning) library. If you use this work, please cite the original VAMP paper:

@InProceedings{vamp_2024,
  author = {Thomason, Wil and Kingston, Zachary and Kavraki, Lydia E.},
  title = {Motions in Microseconds via Vectorized Sampling-Based Planning},
  booktitle = {IEEE International Conference on Robotics and Automation},
  pages = {8749--8756},
  url = {http://arxiv.org/abs/2309.14545},
  doi = {10.1109/ICRA57147.2024.10611190},
  date = {2024}
}

If you use the point-cloud collision checking (CAPT) components, please also cite:

@InProceedings{capt_2024,
  author = {Ramsey, Clayton W. and Kingston, Zachary and Thomason, Wil and Kavraki, Lydia E.},
  title = {Collision-Affording Point Trees: {SIMD}-Amenable Nearest Neighbors for Fast Collision Checking},
  booktitle = {Robotics: Science and Systems},
  url = {https://www.roboticsproceedings.org/rss20/p038.pdf},
  doi = {10.15607/RSS.2024.XX.038},
  date = {2024}
}

License

This project is released under the MIT License.