ManipulationPlanning-SI-RRT

Combination of Rapidly-Exploring Random Trees (RRT) and Safe Interval Path Planning (SIPP) for high-DOF planning in dynamic environments, i.e., planning a path for a manipulator when moving obstacles are present and their trajectories are known or accurately predicted.

Important

🚀 Best Student Paper Award — ICAPS 2025

This repository contains the code for the paper:

Kerimov N., Onegin A., Yakovlev K.
Safe Interval Randomized Path Planning For Manipulators.

Official ICAPS publication:

• [Paper page]
• [Official PDF]
• [Full text on arXiv]

Table of Contents

• Overview
• Supported Algorithms
• Repository Structure
• Code Structure
• Installation
• Quick Start
• Analyze Data
• Citing This Work
• Contact

Overview

This repository contains the source code for path planning in dynamic environments for manipulators, Blender plugins, and utilities for creating, running, and visualizing benchmark scenarios.

Supported Algorithms

The following path planning algorithms are implemented:

DRGBT — Dynamic Rapidly-exploring Generalized Bur Tree

Description: A reactive planner for manipulators that dynamically replans the path based on the distance to obstacles.

Implementation: Forked from the RPMPLv2 library and modified to use our collision detection functions.

ST-RRT* — Space-Time RRT*

Description: A deliberative anytime planner that operates directly in the space-time domain to find collision-free paths.

Implementation: Forked from the OMPL library and adapted for our framework.

SI-RRT — Safe Interval RRT

Description: Our deliberative planner that uses safe intervals for planning in dynamic environments.

Implementation: Original implementation developed for this research.

Repository Structure

The repository is organized into several branches:

• main branch [Link]: Contains the up-to-date implementation of the algorithm, including multi-agent tasks.
• reproducibility-version branch [Link]: Contains the version of the algorithm used in the paper experiments.

Code Structure

The codebase is organized into the following main directories:

• MSIRRT/: Implementation of the Safe Interval RRT algorithm.

• STRRT_Planner/: Space-Time RRT* implementation.

• RPMPLv2/: DRGBT implementation, submoduled from RPMPLv2.

• Blender/: Scripts and plugins for Blender visualization:

  • urdf_importer/: Blender add-on for importing URDF files. Compress it to .zip and install it in Blender. Originally based on blender-urdf-importer, with substantial modifications.
  • scenes/: Example Blender scene files for simulation and visualization.
  • robots/: URDF and mesh files for supported robot models.
  • scripts/: Utility scripts for exporting, importing, batch processing Blender scenes, and creating large-scale tests.

  For detailed information, please refer to the Blender Guide.

• mass_test/: Scripts for running batch experiments:

  • do_mass_test.py: Main script for executing tests in parallel.
  • clean_experiments.py: Utility for cleaning test results.
  • final_analysis.ipynb: Jupyter notebook for analyzing test results.

• docker/: Docker configuration files for reproducible environments.

• tests/: Test cases and benchmark scenarios.

Installation

For detailed installation instructions and dependencies, please refer to the Installation Guide.

Quick Start

Follow these steps to quickly get started with the framework:

1. Download the test dataset:

   url='https://disk.yandex.ru/d/-73LOGO5kOSYuA'; curl -fL -o dataset.tar.gz "$(curl -fsSLG --data-urlencode "public_key=$url" 'https://cloud-api.yandex.net/v1/disk/public/resources/download' | python3 -c 'import sys,json; print(json.load(sys.stdin)["href"])')"
   tar -xvf ./dataset.tar.gz

2. Configure parallel execution:

   Open ./mass_test/do_mass_test.py and set the NUM_CPUS variable.

   Recommended value: the number of available CPU cores minus one.

3. Set up the Docker environment:

   make pull_docker
   make clean_experiments_result
   make enter_debug_docker

4. Build the planners and run tests:

   cd ./app
   make build_planner_debug
   make mass_tests

5. Verify successful execution:

   Check that result files are present in the mass_test/tests directory and that no error messages were printed during execution.

Analyze Data

To analyze experiment results, open the Jupyter notebook:

./mass_test/final_analysis.ipynb

The dataset used in the original paper is available at:

https://disk.yandex.ru/d/-73LOGO5kOSYuA

Citing This Work

If you use this repository in your research, please cite the following paper:

@article{Kerimov_Onegin_Yakovlev_2025,
   title={Safe Interval Randomized Path Planning For Manipulators},
   volume={35},
   url={https://ojs.aaai.org/index.php/ICAPS/article/view/36120},
   DOI={10.1609/icaps.v35i1.36120},
   number={1},
   journal={Proceedings of the International Conference on Automated Planning and Scheduling},
   author={Kerimov, Nuraddin and Onegin, Aleksandr and Yakovlev, Konstantin},
   year={2025},
   month={Sep.},
   pages={213–217}
}

Contact

For questions or further information, please contact:

• Kerimov Nuraddin (kerimov.nm@phystech.edu)

If you encounter any issues with the code, documentation, or reproducibility, please feel free to open a GitHub issue. Feedback and suggestions are welcome.