Efficient Path Planning In Manipulation Planning Problems by Actively Reusing Validation Effort

TL;DR

This paper introduces a method for manipulation path planning that decomposes collision checks to enable active reuse of previous planning efforts across multiple queries, significantly reducing initial solution times.

Contribution

It proposes a novel decomposition of collision checking in manipulation planning, facilitating multiquery reuse and active effort minimization in path planning algorithms.

Findings

Reusing collision check information reduces initial planning time by up to 50%.

The approach outperforms traditional planners in multiquery scenarios.

Decomposition enables knowledge transfer across different problem instances.

Abstract

The path planning problems arising in manipulation planning and in task and motion planning settings are typically repetitive: the same manipulator moves in a space that only changes slightly. Despite this potential for reuse of information, few planners fully exploit the available information. To better enable this reuse, we decompose the collision checking into reusable, and non-reusable parts. We then treat the sequences of path planning problems in manipulation planning as a multiquery path planning problem. This allows the usage of planners that actively minimize planning effort over multiple queries, and by doing so, actively reuse previous knowledge. We implement this approach in EIRM* and effort ordered LazyPRM*, and benchmark it on multiple simulated robotic examples. Further, we show that the approach of decomposing collision checks additionally enables the reuse of the gained knowledge over multiple different instances of the same problem, i.e., in a multiquery manipulation planning scenario. The planners using the decomposed collision checking outperform the other planners in initial solution time by up to a factor of two while providing a similar solution quality.

Tables

Table 1. TABLE I : Median time to initial solution and the corresponding initial cost from 100 runs. The sub and supscripts are the lower and upper nonparametric 95% confidence bounds. The best values for each problem are in bold . The planners above the dashed line are single-query planners, the planners below are multiquery planners using decomposed collision checking.

Scenario	Wall Gap (2D)		Multi Insertion (3D)		Binpicking (7D)		Brickwall (8D)		Handover (14D)
Number of Actions	2		4		2		12		3
	$t_{\text{init}}$	$c_{\text{init}}$	$t_{\text{init}}$	$c_{\text{init}}$	$t_{\text{init}}$	$c_{\text{init}}$	$t_{\text{init}}$	$c_{\text{init}}$	$t_{\text{init}}$	$c_{\text{init}}$
RRT-Connect	$0.387$\stackanchor $+0.04$ $-0.04$	$6.31$\stackanchor $+0.34$ $-0.34$	$0.728$\stackanchor $+0.08$ $-0.04$	$28.26$\stackanchor $+1.27$ $-1.21$	$1.40$\stackanchor $+0.15$ $-0.10$	$17.22$\stackanchor $+0.90$ $-0.65$	$5.48$\stackanchor $+0.37$ $-0.53$	$141.37$\stackanchor $+4.98$ $-4.27$	$2.42$\stackanchor $+0.30$ $-0.24$	$23.39$\stackanchor $+0.43$ $-0.65$
EIT*	$0.100$\stackanchor $+0.00$ $-0.00$	$3.37$\stackanchor $+0.01$ $-0.01$	$0.127$\stackanchor $+0.01$ $-0.00$	$10.71$\stackanchor $+0.11$ $-0.40$	$1.10$\stackanchor $+0.03$ $-0.05$	$12.98$\stackanchor $+0.49$ $-0.44$	$1.73$\stackanchor $+0.06$ $-0.05$	$58.59$\stackanchor $+1.14$ $-2.47$	$3.80$\stackanchor $+0.22$ $-0.18$	$15.63$\stackanchor $+0.97$ $-0.40$
\hdashlineLazyPRM*	$0.206$\stackanchor $+0.01$ $-0.02$	$3.34$\stackanchor $+0.01$ $-0.01$	$0.178$\stackanchor $+0.01$ $-0.01$	$9.91$\stackanchor $+0.13$ $-0.07$	$1.13$\stackanchor $+0.15$ $-0.10$	$11.84$\stackanchor $+0.48$ $-0.27$	$2.49$\stackanchor $+0.36$ $-0.23$	$48.36$\stackanchor $+1.50$ $-1.59$	$1.27$\stackanchor $+0.11$ $-0.13$	$11.09$\stackanchor $+0.26$ $-0.22$
eo-LazyPRM*	$0.150$\stackanchor $+0.01$ $-0.01$	$3.47$\stackanchor $+0.03$ $-0.01$	$0.163$\stackanchor $+0.01$ $-0.01$	$11.94$\stackanchor $+0.15$ $-0.35$	$0.884$\stackanchor $+0.04$ $-0.05$	$13.47$\stackanchor $+1.13$ $-0.57$	$1.86$\stackanchor $+0.14$ $-0.13$	$55.34$\stackanchor $+2.92$ $-2.36$	$1.23$\stackanchor $+0.13$ $-0.06$	$11.19$\stackanchor $+0.94$ $-0.20$
EIRM*	$0.098$\stackanchor $+0.00$ $-0.00$	$3.42$\stackanchor $+0.02$ $-0.02$	$0.114$\stackanchor $+0.01$ $-0.00$	$10.78$\stackanchor $+0.33$ $-0.14$	$0.945$\stackanchor $+0.07$ $-0.09$	$13.93$\stackanchor $+1.15$ $-0.46$	$1.55$\stackanchor $+0.04$ $-0.06$	$51.25$\stackanchor $+0.66$ $-1.85$	$1.28$\stackanchor $+0.06$ $-0.14$	$11.47$\stackanchor $+0.64$ $-0.33$

Equations

$${\mathcal{C}}_{\text{free},i}={\mathcal{C}}_{\text{free}}\cap {\mathcal{C}}_{\text{free}}({\theta }_{{\mathcal{M}}_i})\cap {\mathcal{C}}_{\text{free}}({\Theta }_i),$$

$$e(q,q^{\prime })=e_{r/s}(q,q^{\prime })+e_{o/s}(q,q^{\prime }|{\theta }_{{\mathcal{M}}_i})+e_{r/o}(q,q^{\prime }|{\Theta }_i),$$

$$d(q)=\max \{e(q,q_{i,\text{goal}})-(e_{\text{reusable}}-e_{\text{claimed}}),0\}.$$

Full text

We implement this approach in EIRM* and effort ordered LazyPRM*, and benchmark it on multiple simulated robotic examples. Further, we show that the approach of decomposing collision checks additionally enables the reuse of the gained knowledge over multiple different instances of the same problem, i.e., in a multiquery manipulation planning scenario.

The planners using the decomposed collision checking outperform the other planners in initial solution time by up to a factor of two while providing a similar solution quality.

I Introduction

Manipulation planning requires planning both high level decisions on which actions to take (e.g., ‘pick obj1 - place obj1’), and low level planning, including planning of, e.g., grasping positions, and motion planning between start and goal configurations. In this work, we focus on the motion planning part of the manipulation planning problem. When solving the path planning problem of such manipulation planning problems, it is important that the methods are fast and reliable. In path planning, checking if a proposed path is collision-free is usually the most time consuming part [1, 2], particularly when finding the initial solution [3].

Manipulation planning problems are typically solved sequentially. That is, in the example above, the planner first computes a path for the ‘pick’-action and then subsequently for the ‘place’-action. This means that there is potential for reuse of gained information from previously solved planning queries. To minimize overall planning time, it is desirable to actively reuse information that we gained in the current and during previous planning queries. However, directly reusing information of (in)valid motions is not possible since the environment can change during planning (e.g. by moving an obstacle), and so can the effective collision shape of a robot (by picking up and transporting an object), and previously valid motions can become invalid, or vice versa.

In most planners used for manipulation planning, knowledge gained during previous planning queries is discarded [4] (i.e. after already having planned the movement for picking up an object, the planner starts from scratch when searching for a path to place an object somewhere), or only used to bias the planning process in new queries [5]. The planner effectively needs to re-discover and re-validate the same edges repeatedly, wasting computational effort.

We propose an approach that enables the reuse of collision information throughout the complete manipulation planning problem. We then treat the sequence of motion planning problems in a single manipulation planning problem as a multiquery motion planning problem. By doing so, we are able to reuse collision information that was gained in previous planning queries. We implement this approach in two planners that can actively reuse effort: Effort informed Roadmaps (EIRM*) [6] and a version of LazyPRM* with an effort ordered search.

By grouping all collision objects into i) robot, ii) movable objects, and iii) static environment, a full collision check of a scene can be separated into five collision checks (Fig. 1): robot-robot, robot-static environment, robot-movable objects, movable objects-movable objects, and static environment-movable objects. Of these checks, the first two (robot-robot and robot-static environment) are reusable over all possible motion planning queries, as long as the robot and the static environment do not change. This decomposition and reuse of information does not change completeness or optimality properties of the motion planning algorithms it is used in.

We demonstrate our approach on multiple simulated robotic problems. We provide ablation studies, and compare planners using our approach to other state-of-the-art single-query planners that do not reuse information.

Finally, we also present our planner in a setting where similar manipulation planning problems have to be solved repeatedly, i.e., in a multiquery manipulation planning setting. Our approach allows for reuse of gained information both among different actions in a single manipulation planning problem, and among multiple manipulation queries, and only requires minimal modifications in the planning algorithm.

II Related Work

II-A Path planning in manipulation planning

Manipulation planning is a special case of Task and Motion planning (TAMP) and is concerned with finding a sequence of actions, possibly their parametrizations, and corresponding paths to manipulate a set of objects into a desired final state. During manipulation planning, the environment can be changed, e.g., by moving objects. Examples for such problems often occur in construction [7], or assembly planning [8].

Probabilistic tree-of-roadmaps (PTR) [4] randomly samples actions and then tries to find paths in the mode corresponding to the action. The path planner used in PTR is a single-query planner that is instantiated newly for each action and attempt, and does not reuse any information.

A special case of a manipulation planning problem was presented in [9], where the strong assumption is made that a transition does not change the free configuration space. While that minimizes the number of required attempts that are needed to find a feasible solution, no information is reused between actions.

The knowledge from previous planning queries can be reused to bias new paths towards paths that are known valid from a previous planning query [5, 10, 11]. While paths are biased towards known valid paths, previous (possibly reusable) collision checks are not reused.

Schmitt et al. [12] present a manipulation planning approach that samples parametrizations of modes, and builds separate roadmaps for each parametrization. The method then attempts to connect these separate roadmaps. This approach can reuse previous plans, but it does so only in a very specific case, and not deliberately.

Task and Motion Informed Trees [13] uses an asymmetric search to delay the computationally expensive operations, but does not explicitly reuse any gained information from the various solution attempts and does not reuse any information between the modes of the multi modal planning problem.

None of the presented approaches reuse validation effort in their path planning subroutine, as is possible with the approach we present. The method we present can be used in the approaches discussed above to enable them to reuse previously invested effort as well.

II-B Multiquery path planning

Multiquery path planning tries to efficienly solve multiple motion planning queries in the same (static) space. Many multiquery planners are based on probabilistic roadmaps (PRM) [14], and variants thereof (e.g., (Lazy)PRM(*) [15, 1]). These planners reuse previously invested planning effort if an edge is used in a path that was previously validated, but do not actively try to maximize reuse. In practice this does not lead to much reuse in a planning query.

Lightning [16] is a framework based on sparse roadmaps (SPARS) [17] that retrieves existing plans from a database and adapts them to the current setting. As inserting and retrieving paths into and from SPARS can be computationally expensive, the overall planner might overall be slower than a planner that does not reuse information.

Experience graphs (E-Graphs) [18] actively reuse previously collision checked edges, but are computationally slow as an all-pairs shortest path algorithm needs to be ran repeatedly.

Reconfigurable Random Forest (RRF) [19] combines a graph search with tree-based methods to obtain a multiquery planner. By growing new trees anchored at the start and goal respectively, and planning paths towards the existing other trees, a roadmap is built iteratively over the queries. This approach does not give any optimality guarantees, and is not anytime. Additionally, the roadmap that is constructed can grow indefinitely, which slows down subsequent planning queries.

EIRM* [6], actively reuses previously invested computational effort by ordering its search for an initial solution by effort. It uses a bidirectional search to first compute heuristics for a subsequent search of the underlying graph. Compared to the other multiquery planners, EIRM* actively manages the graph growth that occurs over multiple queries. EIRM* outperforms other multiquery planners on initial solution time by up to an order-of-magnitude.

None of these approaches can be applied directly to manipulation planning problems since they assume that the environment is static. By decomposing the collision checking, and thus enabling reuse of validation effort, it is possible to reuse validation effort over multiple actions.

III Manipulation Planning as Multiquery Problem

III-A Problem Statement & Notation

We consider a scene consisting of $N$ collision objects with poses $p\in\text{SE}(3)$. We use $\mathcal{O}\subseteq\{1,...,N\}$ to denote the movable objects and $\tau\in\mathcal{O}$ to refer to a specific object. We then use $\theta_{\tau}\in\text{SE}(3)$ to denote the relative transformation of object $\tau$ to its parent frame, i.e. either to the gripper of the robot if an object is currently being manipulated, or to the static environment if it is at rest.

In manipulation planning, a sequence of actions is executed, such as ‘pick(obj1) - place(obj1)’111For a thorough discussion of the concept of an action in manipulation planning, refer to e.g. [20].. We refer to $\Theta_{i}=\{\theta_{\tau}|\tau\in\mathcal{O}\}_{i}$ as the parametrization of a scene during the $i$-th action. We use $\mathcal{M}_{i}\subseteq\mathcal{O}$ to denote the set of objects that are manipulated (e.g. moved) during the $i$-th action of the sequence (in the previous pick and place example, $\mathcal{M}_{1}=\{\},\mathcal{M}_{2}=\{\texttt{obj1}\}$), and use $\theta_{\mathcal{M}_{i}}$ to denote the subset of the parametrization $\Theta_{i}$ that corresponds to the moving objects.

We use $\mathcal{C}\subseteq\mathbb{R}^{n}$ to denote the configuration space of the robot, and $q\in\mathcal{C}$ for a specific configuration of the robot222If multiple robots are present in the scene, we assume $\mathcal{C}=\mathcal{C}_{1}\times...\times\mathcal{C}_{n}$, i.e., the configuration-space is the stacked configuration-space of each robot.. The collision free configuration space during action $i$ is $\mathcal{C}_{\text{free},i}(\Theta_{i})$ and is dependent on the action $i$ that we are currently planning for and the parametrization of all the movable objects. The start state of the robot in action $i$ is $q_{i,\text{start}}$, and the goal state is $q_{i,\text{goal}}$. While this approach easily extends to planning between sets of start and goal states, we only present the version with single states for ease of notation here.

Given a tuple $\alpha_{i}=(q_{i,\text{start}},q_{i,\text{goal}},\mathcal{M}_{i},\Theta_{i})$ consisting of a start, a goal, the subset of objects that moves, and the parametrization of the movable objects, the goal is then to find a collision free path $\pi_{i}(s):[0,1]\mapsto\mathcal{C}_{\text{free},i}$ with $\pi_{i}(0)=q_{i,\text{start}},\pi_{i}(1)=q_{i,\text{goal}}$. Path planning in a manipulation planning problem then consists of a sequence $\mathcal{A}=\{\alpha_{1},...,\alpha_{n}\}$ of path planning problems, where the goal state coincides with the start state of the previous action, and the collision free environment at the end of the $i$-th action is equal to the beginning of the $(i+1)$-th action. We show an example of the starts and goals of such a sequence in Fig. 2. Computing the grasping positions in manipulation planning is an open research question in itself, and we assume that these positions are given.

We denote the planning effort between two states, $q$ and $q^{\prime}$, using $e(q,q^{\prime})$. An example for the planning effort between two states is the computational effort it takes to check if the linear connection between two states is collision free.

We use $\xleftarrow{\scriptscriptstyle+}$ for the addition of two sets, i.e., $A\xleftarrow{\scriptscriptstyle+}B$ denotes $A\leftarrow A\cup B$.

In some cases, it might be desirable to minimize a cost $c(\pi)$ over the path. In this work, we use the path length as cost, but the presented approach works for any additive cost. We denote the admissible estimate of the cost of a path going through state $q$ using $f(q)$.

III-B Decomposed collision checking

The collision free configuration space in action $i$ of the manipulation planning problem can be written as intersection of three collision free configuration spaces:

[TABLE]

where the first part is independent of the parametrization of the environment, the second part is only dependent on the objects that are moved in the current action, and the third part is dependent on all movable obstacles.

With the grouping introduced before (Fig. 1), we obtain 5 collision checks that can be mapped to the decomposed configuration spaces (Eq. 1):

$\mathcal{C}_{\text{free}}$: robot-robot, robot-static 2. 2.

$\mathcal{C}_{\text{free}}(\theta_{\mathcal{M}_{i}})$: movable-static 3. 3.

$\mathcal{C}_{\text{free}}(\Theta_{i})$: movable-movable, robot-movable.

As 1) is independent of both the action $i$ and the parametrization of the movable objects, the collision checking result can be reused in all planning queries. Parts 2) and 3) can be reused if the parametrization $\Theta_{i}$, and the set of moving objects in the current action $\mathcal{M}_{i}$ is the same as in a previous collision check, respectively.

III-C Algorithms

Algorithms 1 and 2 show how reusing knowledge of a collision check is implemented: When collision checking an edge $l$, its validity for each of the parts of the decomposed collision check is either unknown, valid, or invalid. If any of the validity components is invalid, the edge is invalid, and can thus not end up in a path found by the graph search of a planning algorithm. If a part is known valid, the part does not have to be collision checked. The validity of a part thus only has to be checked if it is unknown (Algorithm 2, Algorithms 2, 2 and 2, and Algorithm 1, Algorithms 1, 1 and 1). An edge is then collision checked by interpolating the discrete points of the edge at a given resolution (Algorithm 2, Algorithm 2), and checking if the interpolated configuration is valid (Algorithm 2, Algorithm 2). Once an edge is completely collision checked and no collision was found, all its validity-components are annotated to be valid (Algorithm 2, Algorithms 2, 2 and 2). If an edge is in collision, the part that is in collision is marked as invalid (Algorithm 2, Algorithms 2, 2 and 2), and validate returns false (Algorithm 2, Algorithm 2).

Algorithm 3 shows how this reuse is implemented when solving a manipulation planning problem. We demonstrate the decomposed collision checking in two path planning algorithms that are able to deliberately reuse effort: effort ordered LazyPRM* (Algorithm 4) and EIRM* (Algorithm 5). In both planning algorithms, we assume that an edge-implict random geometric graph $X_{\text{RGG}}$ is used to store the samples that currently make up our approximation of the free space.

Effort Ordered Lazy PRM* (eo-LazyPRM*)

We implement the PRM* based algorithm with sparse collision checking similar to [21], that is, during the graph-search, the edges are checked sparsely. Once a candidate path was found, it is then densely checked (using Algorithm 2). We order the search initially by effort, with cost as a tie-breaker. To achieve optimality, once an initial solution was found, the search is ordered by cost, with effort being the tiebreaker.

We additionally implement the graph size management approach that is implemented in EIRM*: We use batch rewinding: all sampled states are stored in a buffer $\mathcal{B}$, and a new batch of samples (of size $m$) is added from the buffer to the current graph once refine_approximation (Algorithm 6) is called. At the beginning of a motion planning query, we start with an empty graph, and subsequently add the samples from the buffer $\mathcal{B}$ back to the graph. For more details, refer to [6].

Effort Informed Roadmaps (EIRM*)

EIRM* relies on an asymmetric bidirectional search, where a computationally inexpensive reverse search is used to compute problem and approximation specific heuristics. These heuristics are then used to guide a forward search, which fully collision checks the edges. The core changes compared to the implementation described in [6] are how collisions are checked, and how configurations are sampled (i.e. the usage of Algorithms 2 and 6 for validity checking, and refining the graph-approximation, respectively).

III-C1 Effort estimate

We use the validation effort as estimate for the planning effort $e$, i.e. the computational effort necessary to verify that an edge is collision free. The planning effort $e$ between two states is then equal to the Euclidean distance between them, divided by the collision checking resolution.

Given that the collision check can be decomposed into three separate parts that can partially be reused, we can also decompose the validation effort in three parts. We estimate the validation effort required for an edge by summing up the required estimated relative effort of each of the 3 collision checks, i.e.

[TABLE]

where $e_{r/s}$ corresponds to the time required to check if an edge is in $\mathcal{C}_{\text{free}}$, $e_{o/s}$ corresponds to $\mathcal{C}_{\text{free}}(\theta_{\mathcal{M}_{i}})$, and $e_{r/o}$ corresponds to $\mathcal{C}_{\text{free}}(\Theta_{i})$. If the edge between $q,q^{\prime}$ was previously checked and thus already annotated with its validity, that part of the sum is zero.

EIRM* requires an estimate for the a priori effort-to-go $d$ (i.e. the effort to go from a target state to a goal state), which is used to order its reverse search. Compared to [6], where $d$ is 0, we use the more informative

[TABLE]

We track the total reusable effort $e_{\text{reusable}}$ that was invested so far, and the effort $e_{\text{claimed}}$ that was claimed during the search so far (i.e. effort that was already reused). The effort-to-go is then the difference between the effort $e(q,q_{i,\text{goal}})$ that it takes to validate the edge between the current state and the goal, and the remaining effort. That is, we optimistically assume that all the remaining effort is part of the path to the goal.

IV Experiments

We evaluate333All experiments were run on a laptop with an Intel i7-8565U CPU @ 1.80GHz processor with 16GB RAM. We make use of the benchmarking best-practices presented in [22]. our work on the scenarios that are shown in Fig. 3. The action sequences are pick-and-place sequences, except for the Handover-scenario, where the object is picked by the right arm, and handed over to the arm on the left, which then places the object at its goal location.

In the following scenarios, we assume that the grasp positions for the manipulation problems are given. We compute the motions in the manipulation planning problems sequentially, i.e., we first solve the path planning problem for the first action, then for the second action, and so forth.

We use the Fast Collision Library (FCL) [23] for our collision checks. FCL natively offers the possibility to group collision-objects. The relative time saved by decomposing the collision checks, and avoiding checking the robot-robot and robot-static env. interactions is between 20% and 50%.

IV-A Algorithms & Parameters

We compare the planners using our approach against the OMPL [24] implementations of RRT-Connect and EIT* [21] as baselines that do not reuse any information between different queries. Additionally, we show a version of LazyPRM* that uses the decomposed collision check, i.e. is able to reuse information, but orders its search by cost, and thus does not reuse information actively. To manage graph growth in this planner, we implement the same approach as in the effort ordered version.

We choose the collision checking resolution for the problems such that the false positive rate is below 1‰, i.e. one in thousand edges are though to be valid when they are actually invalid. This results in roughly the collision checking resolutions of $10^{-4}$ for the abstract problems and $10^{-3}$ for the robotic problems. For EIT*, EIRM*, and the LazyPRM*-variants, we use a batch size of 500 samples.

IV-B Initial solution times and costs

Each planner was run 100 times with different pseudorandom seeds. The starts and goals were always the same during these 100 runs. As we are interested in the time a planer takes to find the initial solution here, the planners were stopped as soon as a solution was found to the current path planning problem, and the next path planning problem in the manipulation planning sequence was started.

Table I shows the median time to find the initial solution, and the corresponding median initial cost. The success rate, i.e. the percentage of planners that found a solution for all the paths in the complete manipulation planning problem over time is shown in Fig. 4.

The planners that reuse information outperform the planners that do not in initial solution time in all our tests. The achieved cost of the initial solution of the planners that reuse information tends to be slightly lower than the one from the planners that do not reuse information.

IV-C Cost evolution

To analyze the cost convergence of the planners, we ran each planner 100 times for 10s on each planning query of the manipulation planning problem with different pseudorandom seeds.

Figure 5 shows the cost evolution of the solutions over time for each planner, and the corresponding success plot. There is a noticeable speed-difference in the second action, where information can be reused by the multiquery planners.

The planners that reuse information converge to the optimal solution more slowly than EIT*. Since the buffer needs to be filled with uniformly distributed samples to account for future queries, we can not directly sample the informed set. Thus, to sample the informed set, we use rejection sampling, which has a higher computational effort than directly sampling the informed set, once we get close to the optimal solution.

IV-D Multiquery manipulation planning

We show an example where we solve multiple problems of the same family, i.e., variations of the same problem where e.g. objects have different dimensions, or different initial and final positions. Such problems often occur in e.g. in construction [8] or assembly planning [7]. Some additional care has to be exercised with reuse of collision information relating to the movable obstacles: if their shape changed, the collision information relating to them can not be reused. Thus, only the information of the static environment and the robot were reused in this experiment.

We created 10 instances from the same problem family (i.e. scenarios where the initial and final goal, and the shape of the movable object changes), shown in Fig. 6. Each planner was then run on the same 100 sequences made up by shuffling the 10 problem instances.

Figure 7 shows the median initial solution time per query. The planners using the decomposed collision checking outperform the single-query planners by approximately a factor of 2.5. Of the multiquery planners, the ones that actively reuse previously invested effort outperform the one that does not.

IV-E Ablations

IV-E1 Graph size management

We compare the algorithms using effort ordered search to versions of them not using batch rewinding, i.e., we start with all valid samples that were used to find the previous solution.

Figure 8 shows the median initial solution time for the same experiments as discussed in Section IV-D for the algorithms without graph size management.

While in the scenario in on the left, the performance was compareable, in the handover scenario, the unmanaged version performs considerably worse.

Note that in the experiments here, these path planning runs were stopped once an initial solution is found. In case the planner continues after the initial solution to optimize the path, the effect that can be seen here is stronger, and it can even be the case that no solution is found anymore in the given time if no active graph size management is done, since the density of the graph becomes too high (as discussed in [6]).

IV-E2 Active vs. passive effort reuse

We compare a planner that uses the decomposed collision checks but uses a cost ordered search, as is standard in LazyPRM*. Thus, while the planner can reuse information it does not actively try to do so. It is visible both in Table I, and Fig. 7, that the solution times that are obtained by the effort ordered search are smaller than the ones obtained by using the cost ordered search. However, the cost ordered search leads to a smaller cost.

IV-E3 Influence of collision checking resolution

We compare the planning times taken for two scenarios with different collision checking resolutions in Fig. 9. RRT-Connect scales roughly linear with the collision checking resolution, whereas the search based planners scale better.

Note that in these settings, a collision checking resolution bigger than $10^{-3}$ resulted in an intolerably high chance of obtaining an invalid path.

V Discussion & Limitations

The planners that reuse collision information over multiple planning queries consistently outperform planners that do not in initial solution time, and are of compareable or better solution quality (Table I). The difference to planners that do not reuse information is most pronounced when the same problem is solved multiple times, as is the case in a TAMP problem, or a long horizon problem that is solved by decomposing the problem in smaller subproblems (Fig. 7). The approach of decomposing and reusing collision information is more useful if many queries are expected in the same or a similar problem, and the path planning problem is not trivial.

As visible in the collision checking resolution ablation in Section IV-E3, the approach presented here shows most improvement in scenarios where the collision checking is relatively time-intensive, as is typically the case in real robotics examples. While there is an advantage to using the presented approach in simple scenarios as well, it is not as pronounced.

Following the analysis in [3] the nearest-neighbour computation starts to dominate the planning time once the path is optimized and the number of samples increases. A possible approach to decrease this part of the planning time as well would be the implementation of caching nearest neighbour computations.

We believe that the presented approach would benefit from a rigorous analysis of when and how to promote valid edges to earlier batches, as already discussed for EIRM* in [6]. A possible approach to achieve this might be similar to [25], i.e., online learning the central features of the configuration space, and promoting those to the first batch of samples.

VI Conclusion

We presented an approach for algorithms to reuse information in sequential manipulation planning by decomposing collision checking into information that is invariant to changes in the environment, and a part that is not. This allows efficient reuse of previously computed information over multiple planning queries as they occur in manipulation planning, leading to path planning times that are up to twice as fast than the current state of the art.

While we presented the decomposition-based approach to reuse effort on the example of collision checks, the idea behind it could be applied more generally on motion-validity and state-validity checks. For example, force or torque constraints could also be decomposed into independent parts, and parts depending on the specific parametrization of a scene.

In the future, we want to apply this approach to TAMP scenarios, where reuse of the form that we presented arises naturally during planning in one action sequence, where multiple high-level plans are tested, and multiple different grasp positions need to be evaluated. We also believe that this approach would be suitable in decomposed multi-robot path planning [26].

In this work, we only focused on the motion planning part, and both the action sequence, and the grasp positions were given. In future work, the information that is gained during the motion planning queries could be used to e.g. help compute valid grasp positions by biasing towards grasps that were found to be feasible before.