Implementation of our HSCC'25 paper: Multi-layer Motion Planning with Kinodynamic and Spatio-Temporal Constraints.

Paper Link: ACM Org

ArXiv Link : ArXiV

This repository contains a Dockerfile to build and run the Open Motion Planning Library (OMPL) version 1.6.0, and includes the lg-sst-stl project for motion planning with Signal Temporal Logic (STL) constraints.

• OMPL Docker Image with LG-SST-STL Project
  • Table of Contents
  • Building the Docker Image
  • Running the Container with run.sh
  • LG-SST-STL Project
    • Overview
    • Building the Project (Inside Container)
    • Running the Planner (Inside Container)
    • Benchmarking (Inside Container)
    • Visualizing Results (Inside Container)
    • Configuration
  • Notes
  • Customization

To build the Docker image, run the following command from this directory (the one containing the Dockerfile):

docker build -t ompl-docker .

This command builds the image with OMPL 1.6.0 and all necessary dependencies, tagging it as ompl-docker.

The run.sh script provides the easiest way to start the Docker container with the lg-sst-stl project directory mounted correctly.

Prerequisites:

• You must have the lg-sst-stl directory present in the same directory as run.sh.
• You must have built the ompl-docker image using the command above.

Usage:

Simply execute the script from this directory:

./run.sh

This script will:

1. Check if the lg-sst-stl directory exists.
2. Check if the ompl-docker image exists (and build it if not found).
3. Start an interactive Docker container named ompl-lg-sst-stl.
4. Mount your local ./lg-sst-stl directory to /app inside the container.
5. Set the working directory inside the container to /app.

You will be dropped into a bash shell inside the container, within the /app directory (which is your mounted lg-sst-stl project).

This project implements LG-SST-STL: Layer Guided SST with Signal Temporal Logic.

LG-SST-STL extends the Stable Sparse RRT (SST) planner with Signal Temporal Logic (STL) capabilities. It provides efficient motion planning for robotic systems that need to satisfy temporal logic constraints during their motion. The implementation is built on top of OMPL (Open Motion Planning Library) and includes both geometric and kinodynamic planning capabilities.

After starting the container using ./run.sh, you need to build the lg-sst-stl project. Navigate to the /app directory (which should be the default) and follow these steps:

Prerequisites:

• CMake 3.10 or newer (included in the Docker image)
• C++17 compatible compiler (included in the Docker image)
• yaml-cpp library (included in the Docker image)

Build Instructions:

# Inside the container, should already be in /app
cd /app

# Create a build directory (if it doesn't exist)
mkdir -p build
cd build

# Configure and build
cmake ..
make -j4 # Use -j flag for parallel compilation

Once built, you can run the planner or benchmarking tools from the /app/build directory inside the container.

The planner has two main components located in /app/src:

1. STL_Planning: Main planner implementation.
2. benchmarking_stl: Benchmarking tool.

To run the main planner executable:

# Inside the container, from the /app/build directory
./STL_Planning

The planner reads its configuration from files within the /app/data/config directory.

To run the benchmarking tool:

# Inside the container, from the /app/build directory

# Run benchmark with default settings (5 runs)
./benchmarking_stl

# Run benchmark with custom number of runs (e.g., 20) and run number (e.g., 2)
./benchmarking_stl 20 2

Benchmark results will be saved in the /app/data/benchmarking directory.

Scripts for visualizing results are located in /app/scripts. You can run them using Python (available in the container):

# Inside the container, from the /app directory
cd /app/scripts
python visualize_path.py 

Results are typically read from /app/data/results or /app/data/benchmarking.

Planner and environment parameters are configured via YAML files in /app/data/config:

• planner_config.yaml: Contains planner parameters like goalBias, pruningRadius, selectionRadius, time limits, control limits, etc.
• env.yaml: Defines the environment, including state space limits (X_state_limits, Y_state_limits), rectangular obstacles, and task_points with spatio-temporal constraints (position, orientation, and time_bound).

You can modify these files (either from your host machine in the lg-sst-stl/data/config directory or inside the container using an editor like nano or vim) to change the planning problem.

• The Docker image builds OMPL 1.6.0 from source.
• C++17 is required for OMPL 1.6.0.
• The container includes all necessary dependencies for OMPL and the lg-sst-stl project (like yaml-cpp).
• Eigen headers are properly linked.

You can modify the Dockerfile to:

• Install additional dependencies.
• Build with different OMPL options.
• Add other tools or libraries.

If you use our planner in your research, please use the following BibTeX entry.

@inproceedings{10.1145/3716863.3718041,
author = {Chatrola, Jeel and Ajith, Abhiroop and Leahy, Kevin and Chamzas, Constantinos},
title = {Multi-layer Motion Planning with Kinodynamic and Spatio-Temporal Constraints},
year = {2025},
isbn = {9798400715044},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3716863.3718041},
doi = {10.1145/3716863.3718041},
abstract = {We propose a novel, multi-layered planning approach for computing paths that satisfy both kinodynamic and spatiotemporal constraints. Our three-part framework first establishes potential sequences to meet spatial constraints, using them to calculate a geometric lead path. This path then guides an asymptotically optimal sampling-based kinodynamic planner, which minimizes an STL-robustness cost to jointly satisfy spatiotemporal and kinodynamic constraints. In our experiments, we test our method with a velocity-controlled Ackerman-car model and demonstrate significant efficiency gains compared to prior art. Additionally, our method is able to generate complex path maneuvers, such as crossovers, something that previous methods had not demonstrated.},
booktitle = {Proceedings of the 28th ACM International Conference on Hybrid Systems: Computation and Control},
articleno = {5},
numpages = {7},
keywords = {Motion Planning, Robotics, Signal Temporal Logic},
location = {Irvine, CA, USA},
series = {HSCC '25}
}