• Stars
    star
    191
  • Rank 202,877 (Top 4 %)
  • Language
    C++
  • License
    MIT License
  • Created over 5 years ago
  • Updated 8 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Continuous CBS - a modification of conflict based search algorithm, that allows to perform actions (move, wait) of arbitrary duration. Timeline is not discretized, i.e. is continuous.

Continuous-CBS

Continuous CBS (CCBS) is a modification of the Conflict Based Search (CBS) algorithm, that supports actions (both move or wait) of arbitrary duration. CCBS is different from CBS in the way how conflicts and constraints are defined. To handle CCBS constraints the low-level search is inspired by Safe Interval Path Planning (SIPP) algorithm. More info about CCBS can be found at IJCAI19 paper.

The master-version supports both grids and general graphs (roadmaps) as well as it supports the following enhancements:

  • Disjoint Splitting (DS)
  • Prioritizing conflicts (PC)
  • High-level heuristics (H)

The detailed description of these enhancements can be found at AAAI21 paper.

Content

Content that compliments the source code of CCBS is organized into the following folders:

  • Demos - contains animations of the solutions obtained by CCBS.
  • Examples - contains the examples of input/output XML-files required/provided by the algorithm.
  • Instances - contains the archives with the maps and instances (in the format that CCBS supports), that were used for the experimental evaluation described in the abovementioned papers on CCBS.
  • ExpResults - contains the raw tabular results obtained during the experimental evaluation of CCBS algorithm.
  • Releases - not a folder, but the tagged commits that were used to get the results for the corresponding papers.

Getting Started

To go and try this algorithm you can use QtCreator or CMake. Both .pro and CMakeLists files are available in the repository.

Notice, that project uses C++11 standart. Make sure that your compiler supports it.

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

Prerequisites

Qt Creator — a cross-platform C++, JavaScript and QML integrated development environment which is part of the SDK for the Qt GUI Application development framework.

CMake — an open-source, cross-platform family of tools designed to build, test and package software.

Installing

Download current repository to your local machine. Use

git clone https://github.com/PathPlanning/Continuous-CBS.git

or direct downloading.

Built current project using Qt Creator or CMake. To launch the compiled file you will need to pass input XML file as an argument. Output file for this project will be placed in the same folder as input file and, by default, will be named _log.xml. For examlpe, using CMake

cd PATH_TO_THE_PROJECT
cmake .
make

Input and Output files

The examples of input and output files you can find in the Examples folder.

Options

There are some options that can be controlled either through the const.h file or through the input configuration file (see examples):

  • <use_cardinal> - controls whether the algorithm is looking for cardinal and semi-cardinal collisions or not. Possible values are 1(true) or 0 (false).
  • <use_disjoint_splitting> - controls whether the algotihm uses disjoint splitting enhancement or not. Possible values are 1(true) or 0 (false).
  • <hlh_type> - controls whether the algorithm uses high-level heuristics or not. 2 different heursitics are implemented. 0 - HL-heuristic is disabled; 1 - HL-heuristic based on solving linear programming problem (by simplex method); 2 - HL-heurstic based an greedy selection of disjoint cardinal conflicts.
  • <connectedness> - controls the connectedness of the grid. Possible values: 2 - 4 cardinal neighbors; 3 - 4 cardinal + 4 diagonal; 4 - 16 neighbors; 5 - 32 neighbors. In case if the map is represented as roadmap this parameter is ignored.
  • <timelimit> - controls the maximum runtime of the algorithm. Possible values are >0. For example value 60 means that the algorithm can spend up to 60 seconds to find a solution.
  • <agent_size> - controls the size (radii) of the agents' shape. Possible values are in the range (0, 0.5].
  • <precision> - additional option, that controls how precise the end of collision interval is detected (the moment of time when there is no more collision between the agents). The lower the value - the preciser the algorithm finds the end of collision interval, but it takes a bit more time. Possible values are >0.

If some of these tags are not defined in the input configuraton file or there is no config-file, all the values of the absent parameters are taken from the 'const.h' file.

Launch

To launch the application you need to have at least map and task input XML-files with all required information:

./CCBS map.xml task.xml

If you want to control the parameters through the input config file, you need to launch the application with three parameters:

./CCBS map.xml task.xml config.xml

The output file will be placed in the same folder as input files and, by default, will be named as task-file plus _log.xml. For examlpe,

"initial_task_file_name.xml" -> "initial_task_file_name_log.xml"

Build Status

More Repositories

1

ORCA-algorithm

Implementation of ORCA algorithm
C++
114
star
2

AA-SIPP-m

Algorithm for prioritized multi-agent path finding (MAPF) in grid-worlds. Moves into arbitrary directions are allowed (each agent is allowed to follow any-angle path on the grid). Timeline is continuous, i.e. action durations are not explicitly discretized into timesteps. Different agents' size and moving speed are supported. Planning is carried out in (x, y, \theta) configuration space, i.e. agents' orientation are taken into account.
C++
99
star
3

3D-AStar-ThetaStar

Basic algorithms for height map based 3D path planning: BFS, Dijkstra, A*, Theta*
C++
76
star
4

AStar-JPS-ThetaStar

Basic algorithms for single-shot grid-based 2D path finding: BFS, Dijkstra, A*, Jump Point Search (JPS), Theta*
C++
66
star
5

SuboptimalSIPP

Implementation of different versions of Safe Interval Path Planning algorithm that can find bounded-suboptimal solutions.
C++
28
star
6

LPAstar

Lifelong Planning A* (LPA*) is a replanning method that is an incremental version of A* algorithm for single-shot grid-based 2D path finding.
C++
20
star
7

GAN-Path-Finder

Generative Adversarial Networks for Path Planning in 2D
Python
17
star
8

ORCAStarROS

Decentralized navigation system based on ORCA and Theta* algorithms and implemented as ROS nodes
C++
17
star
9

DstarLite

Repository provides an implementation of D*Lite algorithm adapted for single-shot grid-based 2D environment.
C++
17
star
10

Push-and-Rotate--CBS--PrioritizedPlanning

3 algorithms for classical MAPF on 4 connected grid in one project
C++
14
star
11

SIPP-IP

Safe Interval Path Planning with Intervals Projection (SIPP-IP) - a SIPP-based planner capable of handling non-instantaneous accelerations/decelerations of an agent (kinodynamic constraints).
C++
11
star
12

CBS-SIPP

C++ implementation of CBS with using SIPP as a low-level planner
C++
8
star
13

TO-AA-SIPP

Time-Optimal Any-Angle Safe Interval Path Planning
C++
8
star
14

MPPI-Collision-Avoidance

Jupyter Notebook
7
star
15

MultiRobotPathFinding-ROS-Gazebo-Demo

Will appear soon.
Python
5
star
16

CBS--PrioritizedPlanning--MP

C++
3
star
17

LIAN

Heuristic search algorithm for generating smooth paths for single-shot grid-based 2D path finding.
C++
3
star
18

LPLian

Lifelong Planning version of LIAN algorithm
Jupyter Notebook
3
star
19

ASearchVisualizer

Program for visualization of detailed logs of path planning algorithms
C++
2
star
20

LPA-Dlite-nw

Implementation of LPA and D*-lite algorithms, used for search in dynamics grid graphs (NON-WORKING)
C++
2
star
21

AMAPF-MF-BS

Algorithm to solve Anonymous Multi Agent Path Finding problem with Maximum Flow reduction and fast Bulk search.
Makefile
1
star
22

LIAN-old

Algorithm for planning with turn angle limitation on grid maps.
C++
1
star