BITKOMO: Combining Sampling and Optimization for Fast Convergence in Optimal Motion Planning

by   Jay Kamat, et al.

Optimal sampling based motion planning and trajectory optimization are two competing frameworks to generate optimal motion plans. Both frameworks have complementary properties: Sampling based planners are typically slow to converge, but provide optimality guarantees. Trajectory optimizers, however, are typically fast to converge, but do not provide global optimality guarantees in nonconvex problems, e.g. scenarios with obstacles. To achieve the best of both worlds, we introduce a new planner, BITKOMO, which integrates the asymptotically optimal Batch Informed Trees (BIT*) planner with the K-Order Markov Optimization (KOMO) trajectory optimization framework. Our planner is anytime and maintains the same asymptotic optimality guarantees provided by BIT*, while also exploiting the fast convergence of the KOMO trajectory optimizer. We experimentally evaluate our planner on manipulation scenarios that involve high dimensional configuration spaces, with up to two 7-DoF manipulators, obstacles and narrow passages. BITKOMO performs better than KOMO by succeeding even when KOMO fails, and it outperforms BIT* in terms of convergence to the optimal solution.


page 1

page 4


Asymptotically Optimal Sampling-based Planners

An asymptotically optimal sampling-based planner employs sampling to sol...

Long-Horizon Motion Planning via Sampling and Segmented Trajectory Optimization

This paper presents a hybrid robot motion planner that generates long-ho...

ST-RRT*: Asymptotically-Optimal Bidirectional Motion Planning through Space-Time

We present a motion planner for planning through space-time with dynamic...

Sampling-Based Trajectory (re)planning for Differentially Flat Systems: Application to a 3D Gantry Crane

In this paper, a sampling-based trajectory planning algorithm for a labo...

Adaptive Motion Planning with Artificial Potential Fields Using a Prior Path

Motion planning in an autonomous agent is responsible for providing smoo...

RRT2.0 for Fast and Optimal Kinodynamic Sampling-Based Motion Planning

We present RRT2.0: a simple yet efficient tree-based planner for asympto...

Integrating Fast Regional Optimization into Sampling-based Kinodynamic Planning for Multirotor Flight

For real-time multirotor kinodynamic motion planning, the efficiency of ...

I Introduction

Generating optimal motions plans is crucial for almost any robotic tasks ranging from typical manipulation tasks such as bin-picking to autonomous navigation of mobile robots. To solve such tasks, the robotics community relies on two powerful motion planning frameworks: Sampling-based planners and trajectory optimization.

Sampling-based planners like RRT* [13], BIT* [5] or FMT* [11] converge asymptotically to optimal solutions and almost surely provide a solution if one exists [18]. However, these planners are slow at converging to the optimal trajectory, because improvements to the current best solution only arise when we sample a state nearby [28], and often provide non-smooth trajectories that may require post-processing [7].

Trajectory optimization methods like KOMO [32], CHOMP [27], STOMP [12] and TrajOpt [29] use optimization methods and can exploit gradient and second order information to converge to a local optimal solution. These optimization-based methods are typically fast at converging to the local optimum, however, due to the non-convexity of the problem, the optimizer might converge to a locally optimal or even an infeasible trajectory. These methods therefore do not have convergence guarantees, i.e. they may not converge to a solution even if one exists, and the feasibility of the solution often depends heavily on the initial trajectory [21, 19, 10]. Hence, these methods usually work well in environments with few obstacles or when provided with good initial guesses [20], e.g. for post-processing paths produced by sampling-based planners.

In order to combine the benefits of both frameworks, we propose to integrate the asymptotically optimal Batch Informed Trees (BIT*) [5] planner with K-Order Markov Optimization (KOMO) [32, 33]. Combining sampling and optimization helps us play on the strengths of each framework and mitigate their weaknesses. Our novel algorithm, BITKOMO, uses BIT* to iteratively generate non-optimal initial paths that are then optimized by KOMO, which results in quick convergence to local minima. The cost of the optimized path is then used by BIT* to carry a more informed search. With this method, we maintain the asymptotic global optimality guarantees by BIT* while also benefiting from the fast convergence of KOMO (Fig. 1).

At the core of BITKOMO lies a new relaxed edge collision checking method. Relaxed edge collision is an intermediate approach between full and lazy [9] collision checking, where we allow partially-valid edges to remain, because the trajectory optimizer KOMO can often push invalid paths out of collision [33] to converge to feasible solutions. Even though this modification allows for invalid edges, we do not sacrifice any of the asymptotic guarantees provided by BIT*.

Fig. 1: Aggregate plot over all our experiments, showing how BITKOMO converges faster than BIT*, while keeping a similar success rate. KOMO is not included, because it fails to find solutions on more than half of our experiments.

To summarize, we make two major contributions:

  1. Relaxed edge collision checking: A method for BIT* that allows edges partially in collision to be included in the motion tree.

  2. BITKOMO: A planner integrating BIT* and KOMO. We integrate sampling and optimization to obtain fast convergence to the global optimum while maintaining the guarantees provided by the sampler.

Ii Related Work

Combining both asymptotically-optimal planners [14, 28, 6, 30] and trajectory optimization [32, 27, 12, 29, 22] into one concise algorithm is an important long-term goal of the robotics community [8]. There exist three main approaches. The two-step approach, where we run a sampling-based planner like the rapidly-exploring random tree (RRT) [18], or the probabilistic roadmap (PRM) [15] until a valid solution path is found. In a post-processing step [16, 7], we call a trajectory optimizer which optimizes the path to find a (local) optimal solution. This method is the most common approach, but does not hold guarantees on optimality, and does not allow the sampling-based planner to find improved solutions by leveraging information acquired by the optimizer. Our BITKOMO approach improves upon this methodology by tightly integrating sampling and optimization in an iterative fashion. Moreover, we use relaxed collision checking to quickly find partially-valid paths. Optimizers like KOMO [32] can often repair those paths to quickly find a solution.

The second approach is the optimizer-as-steering method, where the integration of sampling and optimization is done using the steering function from the planner. The regionally-accelerated BIT* (RABIT*) [2] is an extension of BIT* that uses an optimizer to push infeasible edges out of collision. However, while the obtained solution cost is often better than BIT*, calls to an optimizer are often expensive and slow down the algorithm. It is also possible to integrate such an approach into a roadmap planner [1], to interleave edge creation and optimization steps. We differ by postponing optimization to the point where a full partially-valid path has been found, which reduces the number of unnecessary calls to the nonlinear optimizer.

Finally, the path-proposal method, where the planner proposes solution paths, which are then send to the optimizer [17]. An important aspect of this method is to propose many diverse solution paths, so that the optimizer has a lesser change to converge to similar solutions. This can be accomplished by leveraging sparse roadmaps [23], to generate diverse initial trajectories which we can then send to the trajectory optimizer [3, 25, 24]. The closest work to ours is [8], where RRT* is integrated with a nonlinear optimizer in an iterative fashion.

Our method is complementary, in that we also use the path-proposal method. However, we differ from previous works by our choice of the underlying components (BIT* and KOMO) and/or the interface. Further, the novel collision checking improves the performance in problems involving narrow passages, when the sampling-based planner fails to find a path in the first place.

Iii Problem Definition

We consider a motion planning problem in a configuration space of the form () where is the free configuration space, is the start configuration, is the goal configuration and is the cost functional mapping a trajectory in the free configuration space to a real number. Our goal is to find a trajectory from , to that is optimal, i.e. the value of is the lowest among all possible paths.

s.t. (1b)

In this paper, we focus on path-length optimization, i.e. . Typical examples of alternative cost functionals are the sum of the velocities squared , and smoothness .

Iv Bitkomo

We develop BITKOMO by integrating BIT* with KOMO. Our planner maintains the asymptotic optimality guarantees of BIT* while converging faster to the global minimum by leveraging trajectory optimization. Because KOMO uses the Augmented Lagrangian algorithm for constrained optimization, it can sometimes push partially invalid paths out of collision. To exploit this feature, we introduce relaxed edge checking, which allows BIT* to produce partially infeasible paths for subsequent optimization with KOMO when necessary.

Iv-a The BITKOMO Algorithm: An overview

Fig. 2: Overview of BITKOMO, which combines the BIT* architecture with our custom relaxed edge checking for path planning, and the KOMO optimizer for path optimization.

Fig. 2 gives an overview of our planner. Our planner requires a valid start state (), a goal state () and the full information about the environment (). We also need to provide the Planner Termination condition () and the edge relaxation constant (). To begin, the BIT* planner samples a batch of configurations and builds an edge-implicit Random Geometric Graph (RGG) [26] [Block A in Fig. 2]. The best edge that can possibly improve the cost to goal is then chosen and passed to the Relaxed Edge Checker [B] to carry out the collision checking. The Relaxed Edge Checker performs a validity check and returns the collision penalty (), an integer that provides a proxy measure for the fraction of the edge that is in collision. The planner uses this integer to decide regarding the addition of the edge to the tree. If an improved path to the goal is found, it is passed to the KOMO optimizer [D] which locally optimizes the path and, if valid, returns the new cost to the BIT* planner. BIT* uses this path cost to prune the unnecessary vertices and edges and carry out a more focused search. When no new edges can be expanded, the Sample function [C] is called, which adds another batch of samples to the RGG.


1:; ; ;

2:; ;
4:; ;

6:while  do
7:     if  and  then

8:         ;
9:         ;
10:     end if

11:     while  do

12:         ;
13:     end while
14:     ;

15:     if  then

16:         ;
17:         if  then If true, Edge is used

18:              ;
19:              if  then
20:                  ;

21:                  ;

22:                  if  then If path is feasible
23:                       ;
24:                  end if
25:                  ;
26:                  ;
27:                  if  then
28:                       ;
29:                       ;
30:                  end if

31:              end if
32:         end if
33:     end if
34:end while
35:return Solution;





Algorithm 1 BITKOMO

Algorithm 1 describes in more detail the different parts of the planner. The highlighted lines are our addition to the BIT* planner. Color blue corresponds to the Relaxed edge collision checking and color orange corresponds to the interface between BIT* and KOMO.

Iv-A1 Initialize (A)

Initialize the vertex set (), the edge set () and the tree () along with the vertex queue (), the edge queue () and the set of unconnected vertices (). We also initialize three important cost parameters: 1) is used by the BIT* tree and also includes partially infeasible edges, 2) is the cost of the best feasible path, and 3) is a penalty cost higher than any feasible path BIT* could converge to.

Iv-A2 Batch Addition (B)

This is called if we run out of edges that can help improve our solution. We then add more vertices to our implicit graph and also prune vertices and edges that cannot improve our solution. A detailed explanation can be found in [4].

Iv-A3 Edge Selection (C)

Checks if expanding any vertex can help us in improving the cost of our solution. If the expansion of a vertex can possibly improve the cost, it is expanded, i.e., relevant vertices and edges are added to the vertex queue () and edge queue () respectively (line 12)

Iv-A4 Edge processing (D)

Decides whether to add the edge to the tree. We first check (line 15) if the new edge assuming collision-free, could improve the overall cost to goal and the cost to go to the new vertex . If yes, then we check the edge for collision (line 16). If the collision penalty is less than our relaxation constant (line 17), we calculate the edge cost as the sum of the collision-free edge () and the collision penalty cost () (line 18) and check if the new edge could actually improve the cost to go (line 19). If yes, then we add the new edge to our tree (line 20). (line 20) function also rewires the tree if necessary.

Iv-A5 KOMO Optimization (E)

If the new edge added to the tree improves the cost to the goal, we optimize it with KOMO (line 26). If the resulting path () is valid, we update the cost () for BIT* to continue in a more informed manner (line 28). For completeness, we also check if the initial guess is valid by checking if the path cost is less than (line 22) and update if valid. The working of KOMO is explained in IV-C.

Fig. 3: Levels in Edge Checking The edge is first subdivided into points and these points are then checked for collision level by level. The number on the nodes represent the level of the node. This example has 3 levels.

Iv-B Relaxed Edge Checking

High dimensional spaces containing narrow passages are challenging for sampling based planners. This is because it is difficult to sample collision free edges through narrow passages. Since KOMO can push paths out of obstacles, we could allow paths partially in collision into the BIT* tree. However, these edges need to be added with sufficient collision penalty, otherwise, we may never get an initial feasible solution, e.g. if a partially infeasible straight line path is added to BIT* and KOMO cannot push it out of collision, BIT* will never explore further. We require our planner to prefer paths that are collision free over paths that are in collision for optimization as the likelihood of finding a feasible trajectory from a collision-free path is higher. We solve this problem by introducing Relaxed Edge Checking which returns a number instead of a boolean which is used to assign a collision penalty (line 18). It returns 0-if edge is collision free, 1-if it fails at the last level, 2-if it fails on the second to last level, and so on.

The Relaxed Edge Checker divides the path into equally spaced points depending on the length and the desired resolution. The collision checking is then conducted level wise (see Fig. 3) so that we increase the resolution of our checking until we have reached the required resolution. We first check the mid point (level 1), then the quarter points (level 2) and so on slowly doubling the resolution of checking. If a point fails in the validity check, an integer, collision penalty () is returned. Where is the total number of levels, and is the level of the failed point. This number provides a proxy measure for the fraction of the edge that is in collision.

Iv-C Komo

K-Order Markov Optimization (KOMO) is a trajectory optimization framework that represents a path with a discrete sequence of waypoints . Cost and constraints are evaluated on up to consecutive waypoints (Markov assumption)

s.t. (2b)

where is a tuple of consecutive states. In our setting, where the goal is to minimize the path length, , and we use as cost the sum of squared distances , which corresponds to .

Inequality constraints correspond to collision avoidance and joint limits and equality constraints model the terminal goal condition . The optimization problem (2) is solved with the Augmented Lagrangian algorithm for constrained optimization. The Markov structure, together with second order information, enables very efficient solving, with complexity linear on the number of waypoints and polynomial on the dimension of the configuration space [32].

Iv-D Convergence and Optimality Guarantees

BITKOMO maintains the convergence and optimality guarantees of BIT* [5]. The additional trajectory optimization can only improve the solution proposed by BIT* (lines 26-30 in Alg. 1). The relaxed edge checking assigns cost (line 18 in Alg. 1) to any edge in collision (recall that is an upper bound on the optimal solution cost, that can be chosen arbitrarily large). Even if the subsequent optimization fails, the edge cost does not prevent BIT* and hence BITKOMO from finding a solution with cost .

V Evaluation

(a) Disc Robot
(b) Kuka from shelf
(c) Kuka into box
(d) Fixed Pandas
(e) Two Mobile Pandas
(f) One Mobile Panda
Fig. 4: Scenarios used in our experimental evaluation. See the supplementary video for the solution trajectories.
(a) Disc Robot in Rooms
(b) Kuka from shelf
(c) Kuka into the box
(d) Fixed Pandas
(e) Two Mobile Pandas
(f) One Mobile Panda
Fig. 5: Results: Success rates and best cost plots for BITKOMO, BIT*, FMT* and KOMO on the 6 different example environments.

V-a Scenarios

We evaluate our algorithm on 6 different robotic scenarios111The results can be verified using the our code available on GITHUB. In all scenarios, the robot moves from the initial configuration (solid color) to the goal configuration (translucent color) (Fig. 4). The trajectories computed by BITKOMO and the baseline algorithms are shown in the supplementary video. We emphasize the challenges of each problem with the keywords: narrow passage,

not informative heuristic

and high-dimensional.

  1. Disc Robot in Rooms: A Disc Robot needs to move from the center of one room to another (Fig. 3(a)). The difficulty is that, to go to the other room, the robot first needs to come out of the starting room and then move to the target room. Challenges: narrow passages and not informative heuristic.

  2. Kuka to reach onto the shelf: The Kuka robot needs to reach the red object at level 1 from it’s current position where the end-effector is at level 2 (Fig.3(b)). Challenges: High-dimensional.

  3. Kuka to reach into a box: The Kuka Robot needs to reach to the object inside the box that is located under a table while avoiding collision with the table or the box (Fig. 3(c)). Challenges: Narrow Passage, High Dimensional.

  4. Two Fixed Pandas: The robotic manipulators (Pandas) need to get to the base of the opposite robot while avoiding hitting each other (Fig. 3(d)). Challenges: High Dimensional.

  5. Two Mobile Pandas in cluttered environment: Two mobile panda robots need to move to the other side of the room while avoiding obstacles and also avoiding each other (Fig. 3(e)). Challenges: High Dimensional, Narrow Passages.

  6. One Mobile Panda to avoid large obstacle: The mobile panda needs to move to catch an object on the other side of the scene, with a large obstacle blocking it’s way (Fig. 3(f)). Challenges: High Dimensional, Narrow Passages.

V-B Baselines

We compare our BITKOMO planner with BIT* [5], KOMO [32] and FMT* [11]. Path length minimization is used as the optimization objective for all the experiments. We used the Open Motion Planning Library (OMPL) [31] framework for the implementations of the sampling based planners and for carrying out the benchmarks.

For the KOMO planner we use the sum of squares of the distances between waypoints as optimization objective, and an initialization with random noise around . The trajectory is represented with a constant number of waypoints (20 points). Random initialization and optimization are executed iteratively until timeout, updating the path cost when a better path is found.

V-C Metrics

We evaluate the planners on 2 different metrics:

  1. Success Rate (%): The % of runs that have found a feasible solution at time . This metric gives information about how fast the planner finds the first feasible path.

  2. Cost: The average best cost of the planner at time . This metric gives us an understanding about how the best cost solution of a planner evolves over time and the practical convergence speed before the timeout.

V-D Experimental Results

For getting unbiased results, all experiments were carried out on the same machine222Intel(R) Core(TM) i5-6200U CPU @ 2.30GHz having 16GB RAM. Every planner was executed 50 times on all the six example scenarios. The maximum execution time however was different for different scenarios depending on the difficulty. The relaxation number was set to 1 for all examples. The results of the benchmarks are shown in Fig. 5.

V-D1 Success Rate

The success rate of BIT* and BIKOMO were higher compared with other planners in all examples except the Two Mobile Pandas example. This scenario has narrow passages which makes it hard for sampling based planners, however, the optimal solution is very similar to a straight line path in the configurations space, making it very easy for KOMO to find a solution here. The relaxed edge checking helps BITKOMO in having a slightly better success rate than BIT* here. Overall, the success rates of BIT* and BITKOMO were found to be very similar because they generate initial paths using the same base algorithm.

V-D2 Cost

BITKOMO decreases the cost significantly faster than BIT*, with better convergence before the timeout. This is because the combination of sampling and optimization converges to the local minima quickly and consistently. We however see an abnormality in Fig.4(a), this is because 1) KOMO is not much faster than sampling for low dimensions, and 2) The waypoints maintain a certain minimum distance from the obstacles to avoid edge collisions.

Overall, we conclude that our planner is mostly as good as BIT* in finding the first feasible solution and slightly faster in high dimensional narrow passage problems, but much faster at converging to the global optimal solution.

Vi Conclusion

Our planner, BITKOMO, combines BIT* and KOMO to achieve fast convergence to the optimal solution while being anytime and asymptotically converging to the global minimum. Our experiments indicate that BITKOMO converges to the global optima, faster than BIT*. BITKOMO also provides convergence guarantees which KOMO fails to provide. Our planner, using Relaxed Edge Checking, exploits the ability of KOMO to move trajectories away from the obstacles that are in collision by allowing partially infeasible paths as initial guesses to the optimizer. This helps BITKOMO find motions through narrow passages faster than BIT*.

Even though we observe faster convergence than BIT* to optimal paths, our planner does not have a better success rate. A dedicated planner could be developed to generate improved initial guesses to the optimizer, resulting in an increased success rate. Our method also depends on the number of waypoints KOMO uses. Too many or too few could hamper the performance of the planner. Future work could be done on automatically choosing the optimal number of waypoints for a given problem. The optimization and sampling modules could easily be parallelized, providing a higher speed-up.

Our experiments clearly demonstrate that BITKOMO can robustly achieve fast convergence to optimal motion plans. This is an important step towards making optimal motion planners converge as quickly as trajectory optimizers—all while keeping asymptotic optimality guarantees.


  • [1] K. V. Alwala and M. Mukadam (2020) Joint sampling and trajectory optimization over graphs for online motion planning. In IEEE International Conference on Intelligent Robots and Systems, pp. 4700–4707. Cited by: §II.
  • [2] S. Choudhury, J. D. Gammell, T. D. Barfoot, S. S. Srinivasa, and S. Scherer (2016) Regionally accelerated batch informed trees (rabit*): a framework to integrate local information into optimal path planning. In 2016 IEEE International Conference on Robotics and Automation (ICRA), pp. 4207–4214. Cited by: §II.
  • [3] S. Dai, M. Orton, S. Schaffert, A. Hofmann, and B. Williams (2018) Improving trajectory optimization using a roadmap framework. In 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 8674–8681. Cited by: §II.
  • [4] J. D. Gammell, T. D. Barfoot, and S. S. Srinivasa (2020) Batch informed trees (bit*): informed asymptotically optimal anytime search. The International Journal of Robotics Research 39 (5), pp. 543–567. Cited by: §IV-A2.
  • [5] J. D. Gammell, S. S. Srinivasa, and T. D. Barfoot (2015) Batch informed trees (BIT*): sampling-based optimal planning via the heuristically guided search of implicit random geometric graphs. In 2015 IEEE international conference on robotics and automation (ICRA), pp. 3067–3074. Cited by: §I, §I, §IV-D, §V-B.
  • [6] J. D. Gammell and M. P. Strub (2021) Asymptotically optimal sampling-based motion planning methods. Annual Review of Control, Robotics, and Autonomous Systems 4, pp. 295–318. Cited by: §II.
  • [7] R. Geraerts and M. H. Overmars (2007) Creating high-quality paths for motion planning. The international journal of robotics research 26 (8), pp. 845–863. Cited by: §I, §II.
  • [8] V. N. Hartmann, O. S. Oguz, and M. Toussaint (2020) Planning planning: the path planner as a finite state machine. Cited by: §II, §II.
  • [9] K. Hauser (2015) Lazy collision checking in asymptotically-optimal motion planning. In IEEE International Conference on Robotics and Automation, pp. 2951–2957. Cited by: §I.
  • [10] J. Ichnowski, Y. Avigal, V. Satish, and K. Goldberg (2020) Deep learning can accelerate grasp-optimized motion planning. Science Robotics 5 (48), pp. eabd7710. Cited by: §I.
  • [11] L. Janson, E. Schmerling, A. Clark, and M. Pavone (2015) Fast marching tree: a fast marching sampling-based method for optimal motion planning in many dimensions. The International journal of robotics research 34 (7), pp. 883–921. Cited by: §I, §V-B.
  • [12] M. Kalakrishnan, S. Chitta, E. Theodorou, P. Pastor, and S. Schaal (2011) STOMP: stochastic trajectory optimization for motion planning. In 2011 IEEE international conference on robotics and automation, pp. 4569–4574. Cited by: §I, §II.
  • [13] S. Karaman and E. Frazzoli (2010) Optimal kinodynamic motion planning using incremental sampling-based methods. In 49th IEEE conference on decision and control (CDC), pp. 7681–7687. Cited by: §I.
  • [14] S. Karaman and E. Frazzoli (2011) Sampling-based algorithms for optimal motion planning. International Journal of Robotics Research 30 (7), pp. 846–894. Cited by: §II.
  • [15] L. E. Kavraki, P. Svestka, J. Latombe, and M. H. Overmars (1996) Probabilistic roadmaps for path planning in high-dimensional configuration spaces. IEEE transactions on Robotics and Automation 12 (4), pp. 566–580. Cited by: §II.
  • [16] J. Kim, R. A. Pearce, and N. M. Amato (2003) Extracting optimal paths from roadmaps for motion planning. In IEEE International Conference on Robotics and Automation, Vol. 2, pp. 2424–2429. Cited by: §II.
  • [17] A. Kuntz, C. Bowen, and R. Alterovitz (2020) Fast anytime motion planning in point clouds by interleaving sampling and interior point optimization. In Robotics Research, pp. 929–945. Cited by: §II.
  • [18] S. M. LaValle (2006) Planning Algorithms. Cambridge University Press. Cited by: §I, §II.
  • [19] T. S. Lembono, A. Paolillo, E. Pignat, and S. Calinon (2020) Memory of motion for warm-starting trajectory optimization. IEEE Robotics and Automation Letters 5 (2), pp. 2594–2601. Cited by: §I.
  • [20] S. Liu, M. Watterson, K. Mohta, K. Sun, S. Bhattacharya, C. J. Taylor, and V. Kumar (2017) Planning dynamically feasible trajectories for quadrotors using safe flight corridors in 3-d complex environments. IEEE Robotics and Automation Letters 2 (3), pp. 1688–1695. Cited by: §I.
  • [21] W. Merkt, V. Ivan, and S. Vijayakumar (2018) Leveraging precomputation with problem encoding for warm-starting trajectory optimization in complex environments. In IEEE International Conference on Intelligent Robots and Systems, pp. 5877–5884. Cited by: §I.
  • [22] M. Mukadam, J. Dong, X. Yan, F. Dellaert, and B. Boots (2018) Continuous-time gaussian process motion planning via probabilistic inference. International Journal of Robotics Research 37 (11), pp. 1319–1340. Cited by: §II.
  • [23] A. Orthey, B. Frész, and M. Toussaint (2020-04) Motion planning explorer: visualizing local minima using a local-minima tree. IEEE Robotics and Automation Letters 5 (2), pp. 346–353. External Links: Document Cited by: §II.
  • [24] A. Orthey and M. Toussaint (2020) Visualizing local minima in multi-robot motion planning using multilevel morse theory. In Workshop on the Algorithmic Foundations of Robotics, Cited by: §II.
  • [25] C. Park, F. Rabe, S. Sharma, C. Scheurer, U. E. Zimmermann, and D. Manocha (2015) Parallel cartesian planning in dynamic environments using constrained trajectory planning. In 2015 IEEE-RAS 15th International Conference on Humanoid Robots (Humanoids), pp. 983–990. Cited by: §II.
  • [26] M. Penrose (2003) Random geometric graphs. Vol. 5, OUP Oxford. Cited by: §IV-A.
  • [27] N. Ratliff, M. Zucker, J. A. Bagnell, and S. Srinivasa (2009) CHOMP: gradient optimization techniques for efficient motion planning. In 2009 IEEE International Conference on Robotics and Automation, pp. 489–494. Cited by: §I, §II.
  • [28] O. Salzman and D. Halperin (2016) Asymptotically near-optimal rrt for fast, high-quality motion planning. IEEE Transactions on Robotics 32 (3), pp. 473–483. Cited by: §I, §II.
  • [29] J. Schulman, Y. Duan, J. Ho, A. Lee, I. Awwal, H. Bradlow, J. Pan, S. Patil, K. Goldberg, and P. Abbeel (2014) Motion planning with sequential convex optimization and convex collision checking. The International Journal of Robotics Research 33 (9), pp. 1251–1270. Cited by: §I, §II.
  • [30] M. P. Strub and J. D. Gammell (2021) AIT* and EIT*: asymmetric bidirectional sampling-based path planning. arXiv preprint arXiv:2111.01877. Cited by: §II.
  • [31] I. A. Sucan, M. Moll, and L. E. Kavraki (2012) The open motion planning library. IEEE Robotics & Automation Magazine 19 (4), pp. 72–82. Cited by: §V-B.
  • [32] M. Toussaint (2014) Newton methods for k-order markov constrained motion problems. arXiv preprint arXiv:1407.0414. Cited by: §I, §I, §II, §IV-C, §V-B.
  • [33] M. Toussaint (2015) Logic-geometric programming: an optimization-based approach to combined task and motion planning. In

    International Joint Conference on Artificial Intelligence

    Cited by: §I, §I.