A Certified-Complete Bimanual Manipulation Planner

TL;DR

This paper introduces a certified-complete bimanual manipulation planner that guarantees finding a solution for moving objects with two robot arms, validated through software and hardware tests on furniture.

Contribution

It presents a novel manipulation planning algorithm that is certified-complete, providing guarantees and a constructive certificate for bimanual manipulation tasks.

Findings

Algorithm is certified-complete for given environments.

Successfully tested on large furniture pieces.

Provides quick solutions at run-time using the certificate.

Abstract

Planning motions for two robot arms to move an object collaboratively is a difficult problem, mainly because of the closed-chain constraint, which arises whenever two robot hands simultaneously grasp a single rigid object. In this paper, we propose a manipulation planning algorithm to bring an object from an initial stable placement (position and orientation of the object on the support surface) towards a goal stable placement. The key specificity of our algorithm is that it is certified-complete: for a given object and a given environment, we provide a certificate that the algorithm will find a solution to any bimanual manipulation query in that environment whenever one exists. Moreover, the certificate is constructive: at run-time, it can be used to quickly find a solution to a given query. The algorithm is tested in software and hardware on a number of large pieces of furniture.

Tables

Table 1. TABLE I: Computation Time for Computing Certificates and Solving Queries for the Objects in Fig.  6 .

			Object $1$	Object $2$	Object $3$	Object $4$	Object $5$	Object $6$
# placement classes			$4$	$3$	$6$	$6$	$8$	$6$
# grasp classes			$1849$	$2601$	$2401$	$3364$	$1089$	$784$
Computing Certificates	total computation time	avg. (s.)	$415.97$	$281.18$	$867.71$	$1030.44$	$1374.27$	$574.54$
		std. (s.)	$141.49$	$98.48$	$212.54$	$288.06$	$342.11$	$120.29$
	*planning (s.)		$154.36$	$94.07$	$604.19$	$556.92$	$582.54$	$199.63$
	*grasp check (s.)		$101.69$	$76.27$	$202.90$	$227.51$	$157.90$	$154.11$
	*shortcutting (s.)		$14.51$	$7.29$	$32.76$	$33.55$	$34.83$	$23.58$
	# TypeB trajectories (avg.)		$4.00$	$2.00$	$11.02$	$10.84$	$11.98$	$7.40$
	success rate		$1.0$	$1.0$	$1.0$	$1.0$	$1.0$	$1.0$
Solving Queries	total computation time	avg. (s.)	$103.65$	$45.08$	$127.45$	$234.54$	$109.99$	$185.08$
		std. (s.)	$18.04$	$14.93$	$29.93$	$55.96$	$24.37$	$31.55$
	# TypeB trajectories (avg.)		$2.0$	$2.0$	$2.0$	$2.0$	$2.0$	$2.0$

Equations

$$\mathscr{A}=\big{\{}\mathscr{B}(h_{1}),\,\mathscr{B}(h_{2}),\,\mathscr{B}(h_{3}),\,\ldots\big{\}},$$

Full text

Note to Practitioners—@IEEEgobbleleadPARNLSP This paper presents an algorithm to solve a difficult class of bimanual manipulation planning problems where a movable object can be moved only when grasped by two robots. These problems arise naturally when manipulating a large and/or heavy object such as a piece of furniture. With a given object and environment, we provide a method to compute a certificate that the algorithm will find a solution to any bimanual manipulation query in that environment whenever one exists. The certificate can also be used to quickly construct a solution to a given query. The algorithm is tested in software and hardware on a number of large pieces of furniture.

I Introduction

Large or heavy objects are best manipulated using two hands. Humans are good at bimanual manipulation: think of how we can, for example, effortlessly manipulate a large piece of furniture (Fig. 1(a)). By contrast, bimanual manipulation is still challenging for robots, mainly because of the closed-chain constraint, which arises whenever two robot hands simultaneously grasp a single rigid object (Fig. 1(b)). This constraint poses significant challenges for manipulation planning since it (i) reduces the dimension of the configuration space [1], and (ii) restricts the range of motion of each robot arm [2]. Thus, while unimanual manipulation planning is a relatively established research field with solid theoretical foundations and a number of working demonstrations (see e.g., [3, 4, 5, 6] and references therein), results in bimanual manipulation planning are still scarce, see Section II for a review.

This paper specifically considers the harder class of problem instances where the manipulated object can be moved only when grasped with both hands, which is the case for large or heavy objects. We propose a manipulation algorithm to bring the object from an initial stable placement (position and orientation of the object on the support surface) towards a goal stable placement. The algorithm works at two levels: task-planning and motion-planning. At the task-planning level, a sequence of stable intermediate placements where the object can be ungrasped and regrasped is found. At the motion-planning level, the motions of the two arms (when they carry the object between two intermediate placements or when they move freely while the object is at an intermediate placement) are determined.

The key specificity of our algorithm is that it is certified-complete: for a given object and a given environment, we provide a certificate that the algorithm will find a solution to any bimanual manipulation query in that environment whenever one exists. Moreover, the certificate is constructive: at run-time, it can be used to quickly find a solution to a given query. The algorithm is tested in software and hardware on a number of large pieces of furniture. An implementation is openly available at https://gitlab.com/puttichai/pymanip.

Proofs of completeness have been obtained for some classes of motion planning algorithms, under more or less restrictive and verifiable assumptions [7, 8]. However, to our knowledge, there currently exists no complete or certified-complete bimanual manipulation planner. This is because, in addition to the motion-planning level, manipulation planners include the task-planning level, whose completeness properties are difficult to formalize and to prove. Nevertheless, completeness results are crucial for automation, where time is a valuable asset. Certified-completeness, for example, eliminates the need to spend computation time searching for non-existent manipulation paths. Computed certificates also help the algorithm to find shorter manipulation paths since the robots will only bring the object to different placements only if necessary.

The rest of the paper is organized as follows. In Section II, we review related works in manipulation planning. In Section III, we introduce the background of manipulation planning and give an overview of the proposed bimanual manipulation planner. In Section IV and Section V, we discuss main components of the proposed planner and introduce the notion of certificate. In Section VI, we present software and hardware experiments to validate our approach. Finally, in Section VII, we discuss the advantages and limitations of the approach and sketch some direction for future work.

II Related Works

II-A Bimanual Manipulation Planning

In a pioneering work [9], the authors considered the problems with the constraint that the movable object could only be moved when grasped by both arms, similar to ours. The proposed solutions were based on discretization of the configuration space. Their applicability were therefore limited to low-dimensional problems.

Apart from [9], most existing works on bimanual manipulation fall into one of the following paradigms:

1. a)

Passing an object from one hand to another [10, 11, 12, 13]. These motions can be seen as a way to increase the workspace volume of the system or to help solve single-arm manipulation problems more easily. 2. b)

Focusing on control of interactions (robot-robot, robot-object, or object-object). Examples include assembly manipulation [14, 15, 16, 17] and objects handling [18]. 3. c)

Discussing only reaching motions [19, 20, 21] or non-cooperative tasks [22, 23]. This case is most similar to the usual multi-arm path planning where robot arms move independently but coordinatively to reach their goals without colliding with one another. 4. d)

No regrasping. In [24, 25], the start and goal configurations are closed-chain configurations. This case is more related to closed-chain motion planning. 5. e)

Others. For example, in [26], the authors solved a manipulation problem by sequentially generating a sequence of object contact states, object poses, and manipulator contact points. They, however, did not take into account robot kinematics. In [27], the authors discussed a problem of a bimanual robot manipulating a foldable chair. The task was solved via chair state discretization.

A more thorough survey of work on bimanual manipulation can be found in [28].

The problem we are interested in, however, is a combination of various subproblems, including c) and d) mentioned above as well as the regrasping problem.

Although the problem itself is similar in nature to the one tackled in [9], the setting here is more practical. Our approach can deal with problems with high degrees-of-freedom (DOF). Furthermore, while the planners presented in [9] did not have any performance guarantee, our proposed planner is certified-complete.

II-B Completeness Results in Manipulation Planning

Manipulation planning can be viewed as a member of a broader class of problems, so-called multi-modal motion planning, in which the configuration space has multi-modal structure and each mode limits possible motions to a submanifold. For the manipulation planning problem that we consider here, the available family of modes of motions consist of transit and transfer; each family comprises infinitely many modes. For example, each mode in the transit family corresponds to one object placement.

In [29], the authors presented a probabilistically complete multi-modal planner, which, however, applicable to only problems with finite modes. A more relevant result was published in [30] where the authors presented a planner, Random-MMP, which can deal with infinite number of modes. Despite the probabilistic completeness guarantee, using Random-MMP directly to solve a pick-and-place task poses critical disadvantages. This is mainly due to unsupervised mode switches: consider for example when the object is at rest on a supporting surface without being grasped by any robot (i.e., the configuration is in a transit mode), Random-MMP will proceed by simply sampling an adjacent mode, which is essentially sampling any grasp (transfer mode). Without utilizing knowledge of how grasps and placements correlates, as is done, e.g., in [6], the planner can be very slow since it indeed needs to randomly sample a correct order of a correct combinations of grasps and placements before it can eventually reach the goal. Furthermore, the probabilistic completeness of Random-MMP relies on the expansiveness of the space of all modes, which is difficult, if not impossible, to characterize or verify.

In this work, we introduce a more practical notion of completeness, namely certified-completeness. A certified-complete planner computes a certificate which guarantees existence of solutions to any feasible manipulation query. Although the computation of certificates itself is not complete, i.e., there currently exists no theoretical guarantee if such computation will be successful, we show that it is in fact practical to compute such certificates, as presented in Section VI for a number of realistic cases.

Note also that there is also another somewhat related line of research, in which the focus is on computation of space disconnection certificate (see, e.g., [31]).

II-C Regrasping

Generally speaking, regrasping is a grasp-changing operations. Here we are interested in the case when manipulators are equipped with parallel jaw grippers, which are the most common and robust grippers in the industry. Unlike multi-fingered hands which can perform in-hand regrasping, a robot equipped with a parallel gripper has to rely on a support surface, on which the object can be placed stably while ungrasped, to change the grasp.

Works on regrasping utilizes the knowledge that to realize any regrasping motions, the robot(s) must place the object down on the support surface. The system configuration has naturally to satisfy two criteria:

1. the robot(s) must be grasping the object and

2. the object must be at a stable position.

The set of configurations satisfying the aforementioned criteria, denoted as $\mathscr{G}\cap\mathscr{P}$, and connectivity between its different connected component play significant roles in solving regrasping problems.

Pioneering works on regrasping problems, including [32, 33, 34], characterized the set $\mathscr{G}\cap\mathscr{P}$ by means of discretization. Their methods are therefore limited in a number of ways. However, the authors of [32] also proposed an interesting notion of Grasp-Placement Table, based on the discretization of $\mathscr{G}\cap\mathscr{P}$, which captured the connectivity of $\mathscr{G}\cap\mathscr{P}$. More recent work on regrasping such as [5, 6] also employed some kinds of graphs to represent the connectivity.

The set $\mathscr{G}\cap\mathscr{P}$ can, in fact, be grouped into a finite number of subsets, called grasp classes and placement classes [6]. Utilizing these facts, the authors of [6] introduced a high-level Grasp-Placement Graph which showed potential connectivity between different connected components of $\mathscr{G}\cap\mathscr{P}$. They proposed a manipulation planner which, with the guidance from the graph, explored the configuration space efficiently and systematically.

One possible way to solve a bimanual manipulation planning problem is then to extend the high-level Grasp-Placement Graph, originally proposed for unimanual systems, to bimanual cases. However, the combinatorial complexity grows much too high, making this approach not suitable even in the case when the object has a moderate number of grasp classes. For example, consider a unimanual setting. Suppose the start and goal placements have $m$ grasps in common but no transfer path directly connecting the two placement classes exists. The planner will have to explore exhaustively all $m$ paths connecting placements start and goal in the graph before considering any manipulation path with some intermediate placements. In a bimanual setting, the planner will have to explore all $\pazocal{O}(m^{2})$ possibilities in case no direct transfer path exists between the start and goal placements. Suppose there are tens of common grasp classes between the start and goal placements, this means that the planner needs to explore already hundreds of possibilities before trying to plan a manipulation paths with one intermediate placements.

II-D Motion Planning with Closed Kinematic Chains

Closed-chain motion planning is by itself a difficult and challenging problem. Efficient path planners such as Rapidly-exploring Random Trees (RRTs) [35] or their variants cannot be directly applied to solve such problems since the probability of a randomly sampled configuration satisfying the closed-chain constraint is essentially null [1]. This is because the set of valid closed-chain configurations forms a set of manifolds of dimension lower than that of the ambient space. To cope with this issue, various methods have been devised to sample closed-chain configurations and to interpolate closed-chain trajectories.

Random gradient descent was used in [1] to move a randomly sampled configuration towards the constraint manifold. In [36], the authors proposed to break the closed kinematic chain into two subchains. A configuration of one subchain is sampled randomly while a configuration of the other is computed so as to close the chain. This method was further improved in [37]. More recent work samples configurations on a tangent space of the constraint manifold [38, 39].

We take a different approach to closed-chain motion planning. Essentially, to interpolate a trajectory between closed-chain configurations, our planner first interpolates a trajectory for the movable object. The trajectory is then tracked by the two robots. We describe our closed-chain motion planner as well as our rationale in Section V.

III Background and Overview of the Bimanual Manipulation Planning

Algorithm

III-A Background

This Section presents definitions and fundamentals of bimanual manipulation planning built based on previous works [3, 6].

Consider the $3$D space where the bimanual manipulation system is located, called world. The world, $\pazocal{W}$, consists of two robots $\pazocal{R}_{1}$ and $\pazocal{R}_{2}$, a movable object $\pazocal{O}$, and the environment $\pazocal{E}$. Each robot is equipped with a parallel jaw gripper. The environment also includes support surface(s) on which the object is allowed to rest.

Let $\mathscr{C}_{\pazocal{R}_{1}}$ and $\mathscr{C}_{\pazocal{R}_{2}}$ be the configuration spaces of the two robots and $\mathscr{C}_{\pazocal{O}}\subseteq SE(3)$ the configuration space of the object. The composite configuration $\mathscr{C}$ is defined as the Cartesian products of the three aforementioned spaces. Each composite configuration $\bm{c}\in\mathscr{C}$ can then be written as $\bm{c}=(\bm{q}_{1},\bm{q}_{2},\bm{T})$, where $\bm{q}_{1}\in\mathscr{C}_{\pazocal{R}_{1}}$, $\bm{q}_{2}\in\mathscr{C}_{\pazocal{R}_{2}}$ and $\bm{T}\in\mathscr{C}_{\pazocal{O}}$.

We equip with the composite configuration space a metric $d$ defined as a linear combination of Euclidean distance between robot configurations and a distance between the object transformation matrices. In particular, $d(\bm{c}_{a},\bm{c}_{b})=\alpha\left(\left\lVert\bm{q}_{1a}-\bm{q}_{2a}\right\rVert_{2}+\left\lVert\bm{q}_{1b}-\bm{q}_{2b}\right\rVert_{2}\right)+(1-\alpha)w(\bm{T}_{a},\bm{T}_{b})$, where $\alpha\in[0,1]$ and $w$ is the weighted sum of the minimal geodesic distance between two rotations [40] and the Euclidean distance between two displacements.

We now define a grasp and a placement as follows.

Definition 1**.**

A grasp is a relation between the object pose and the grippers’ poses.

One can represent a grasp by, e.g., a pair of relative transformations between each robot gripper and the object. Note that from the definition, any pair of relative transformations can be a grasp. However, the object can be moved only when being grasped by a valid grasp. The set of all valid grasps are to be determined by the users, either explicitly (e.g., as a set of grasps) or implicitly (e.g., as conditions to be satisfied by the grippers). Note also that there can be many pair of robot configurations $(\bm{q}_{1},\bm{q}_{2})$ corresponding to exactly the same grasp due to multiplicity of inverse kinematic (IK) solutions associated with the same grippers’ poses.

The set of all valid grasps can be parameterized by a set of parameters [6], which is finite but not necessarily unique. Consider for example an object composed entirely of boxes111This is not a particularly impractical setting since a piece of furniture tends to be geometric and thus can be approximately, if not exactly, represented by boxes. and a gripper shown in Fig. 2. Grasp parameters may be defined as follows [6]. $l$ is an integer indicating the index of the link (box) that the gripper is grasping. $a$ is an integer indicating how the gripper is approaching the object. Assuming, without loss of generality, that each box is aligned with its local coordinate frame. The integer $a$ may be a number from $1$ to $6$, where if $a=1$, the gripper’s approaching direction is aligned with the $+x$-axis of the box’s local frame; if $a=2$, the gripper’s approaching direction is aligned with the $+y$-axis, etc. $b$ is an integer indicating which axis of the box’s local frame the gripper’s sliding direction is aligned with. And the last parameter222Note that we can have more grasp parameters. For example, the gripper could tilt around the (virtual) axis connecting the two finger tips. We may introduce another parameter $\theta$ to indicate the tilting angle. $\delta$ is a real number indicating the position of the gripper along the sliding direction. For example, if the gripper is grasping the box at the middle, we may assign $\delta=0$, and $\delta$ increases (or decreases) when the gripper slides along the sliding direction. Using this notion, a grasp for the $i^{\text{th}}$ robot may be written as a vector $g_{i}=[l_{i}\,a_{i}\,b_{i}\,\delta_{i}]^{\top}$ and therefore a bimanual grasp may be written as $g=\left[g_{1}^{\top}g_{2}^{\top}\right]^{\top}$.

Definition 2**.**

A placement refers to an object transformation at which the object is in contact with a support surface.

A placement is said to be stable if when not in contact with any robot, the object remains stationary.

The set of all stable placements can be seen as a set of $SE(2)$. They therefore can be parameterized by three parameters $x$, $y$, and $\theta$, where $x$ and $y$ represent the position of some nominal point of the object with respect to the support surface, and $\theta$ represents the rotation around an axis passing through the point $(x,y)$ and perpendicular to the surface.

With the above definitions of grasps and placements, we can now define a collision-free configuration and a feasible configuration.

Definition 3**.**

A composite configuration is said to be collision-free if there is no collision in the world except the ones induced by valid grasps and ones induced by placements.

Definition 4**.**

A composite configuration $\bm{c}=(\bm{q}_{1},\bm{q}_{2},\bm{T})$ is said to be non-singular if the Jacobians of the two robots, $\bm{J}_{\pazocal{R}_{1}}(\bm{q}_{1})$ and $\bm{J}_{\pazocal{R}_{2}}(\bm{q}_{2})$, have maximal rank. Otherwise, the configuration is said to be singular.

Definition 5**.**

*A composite configuration is said to be feasible if it is collision-free and non-singular and at least one of the following holds:

1. The robots are grasping the object with a valid grasp;

2. The object is at a stable placement.

Let us now consider intrinsic structure of $\mathscr{C}$. For convenience, we define a function $\pi_{p}:\mathscr{C}\rightarrow\mathscr{C}_{\pazocal{O}}$ which projects a composite configuration $\bm{c}=(\bm{q}_{1},\bm{q}_{2},\bm{T})$ into $SE(3)$ such that $\pi_{p}(\bm{c})=\bm{T}$. There are two types of subsets of $\mathscr{C}$ induced by valid grasps and stable placements.

Definition 6**.**

Grasp configuration set, $\mathscr{G}$, is the set of feasible composite configurations where the robots are grasping the object with a valid grasp.

Definition 7**.**

Placement configuration set, $\mathscr{P}$, is the set of feasible composite configurations such that

$\forall\bm{c}\in\mathscr{P}$* $\pi_{p}(\bm{c})\text{ is a stable placement}$ and* 2. 2.

$\forall\bm{c}\in\mathscr{P}$* $\exists\bm{c}^{\prime}\in\mathscr{G}$ $\pi_{p}(\bm{c}^{\prime})=\pi_{p}(\bm{c})$.*

The second requirement of the placement configuration set is to ensure that for any placement configuration $\bm{c}\in\mathscr{P}$, its corresponding placement is always reachable by some grasp.

Both $\mathscr{G}$ and $\mathscr{P}$ can be partitioned into a finite number of grasp classes and placement classes, respectively [6]. From the grasp parameters we introduced earlier, we define a grasp class as a subset of $\mathscr{G}$ whose configurations have the same grasp parameters $l$ (link index) and $a$ (approaching direction). For example, if the object is a box, there will be $6$ grasp classes in total. Now consider partitioning of $\mathscr{P}$. Let $\pazocal{H}$ be the convex hull of the object. All stable placements can be grouped based on which surface of $\pazocal{H}$ is in contact with the support surface. Therefore, a placement class is defined as a subset of $\mathscr{P}$ where at each configuration, the same face of $\pazocal{H}$ is in contact with the support surface. For convenience, we will also say that two object transformations are in the same placement class if at both transformations, the same face of the convex hull $\pazocal{H}$ is in contact with the support surface.

There are two types of physically realizable single-mode paths: transit and transfer. A transit path is a path in $\mathscr{P}$ where the placement remains unchanged throughout while a transfer path is a path in $\mathscr{G}$ where the grasp remains unchanged throughout. A manipulation path is defined as an alternating sequence of single-mode paths. To plan a manipulation path, a manipulation query must be provided to a planner. A manipulation query is defined as follows.

Definition 8**.**

A manipulation query, or simply query, $Q$, is a set of information provided to a manipulation planner to solve for a manipulation trajectory. A query consists of at least a pair of stable placements, $\bm{T}_{s}$ and $\bm{T}_{g}$, which are the start and goal object transformations.

A query is said to be feasible if $\bm{T}_{s},\bm{T}_{g}\in\pi_{p}(\mathscr{P})$.

Then a manipulation planning problem can be stated as follows.

Problem 1**.**

Given the description of the world and a query $Q=(\bm{T}_{s},\bm{T}_{g})$, find a manipulation trajectory which brings the object from $\bm{T}_{s}$ to $\bm{T}_{g}$.

III-B *Overview of the Proposed Bimanual Manipulation Planning

Algorithm*

We propose the following approach to solving a bimanual manipulation query:

1. Step 1

Identify the placement classes of $\bm{T}_{s}$ and $\bm{T}_{g}$ as $\mathscr{P}_{s}$ and $\mathscr{P}_{g}$, respectively. 2. Step 2

Generate TypeA trajectory, within the placement class $\mathscr{P}_{s}$, to move the object from $\bm{T}_{s}$ to some $\bm{T}^{\prime}_{s}$. 3. Step 3

Generate TypeB trajectory to bring the object from $\bm{T}^{\prime}_{s}$ to some $\bm{T}^{\prime}_{g}$ in the placement class $\mathscr{P}_{g}$. 4. Step 4

Generate TypeA trajectory, within the placement class $\mathscr{P}_{g}$, to move the object from $\bm{T}^{\prime}_{g}$ to $\bm{T}_{g}$.

A solution to a query will be a sequence of TypeA trajectories, which connect configurations in the same placement class, and TypeB trajectories, which connect configurations from different placement classes.

In the above steps, $\bm{T}^{\prime}_{s}$ (respectively $\bm{T}^{\prime}_{g}$) is an object transformation which can serve as an initial (respectively goal) transformation of the to-be-generated TypeB trajectory. Note also that in some cases, one may need to generate TypeB trajectories to move the object to, and between, some intermediate placements since a direct connection between $\mathscr{P}_{s}$ and $\mathscr{P}_{g}$ may not exist or cannot be found. The procedure can be done by repeating Step 2 and Step 3 until the goal placement $\mathscr{P}_{g}$ is reached.

The completeness of the above approach depends on the completeness of TypeA and TypeB trajectory generation methods. In the remaining of this Section, we give brief overviews of generation of both TypeA and TypeB trajectories, as well as the main algorithm.

III-B1 TypeA

To plan TypeA trajectories, we argue that we can consider the set $\mathscr{T}_{i}\subset SE(2)$ of object configurations (see Section IV for more details) instead of examining a placement class $\mathscr{P}_{i}$, which is a subset of the high-dimensional $\mathscr{C}$.

Given two object configurations $\bm{T}_{1}$ and $\bm{T}_{2}$ in the same connected component of $\mathscr{T}_{i}$, we first generate an object path $\sigma$, as if it could move freely by itself on a support surface. Then we present a procedure to generate a TypeA trajectory which moves the object along $\sigma$. We prove that, given a valid object path, such a TypeA trajectory always exists and that our procedure will terminate with a solution in finite time.

III-B2 TypeB

Since the motions of the system are severely constrained by closed kinematic chains, randomly generating closed-chain queries, where the start and goal configurations are in different placement classes, has slim chances of the queries being solvable. To resolve this issue, we propose a heuristic to generate closed-chain queries in such a way that, by our intuition, does not require a large range of robot motions to solve them.

Now suppose that one has a TypeB trajectory $M^{B}:[0,1]\rightarrow\mathscr{C}$ connecting two placement classes $\mathscr{P}_{i}$ and $\mathscr{P}_{j}$, i.e., $M^{B}(0)\in\mathscr{P}_{i}$ and $M^{B}(1)\in\mathscr{P}_{j}$. Observe that provided that the world does not change, whenever one needs to connect configurations $\bm{c}_{1}\in\mathscr{P}_{i}$ and $\bm{c}_{2}\in\mathscr{P}_{j}$, one can reuse the trajectory $M^{B}$ by planning two TypeA trajectories, $M^{A}_{1}$ and $M^{A}_{2}$, where $M^{A}_{1}$ connects $\bm{c}_{1}$ and $M^{B}(0)$ and $M^{A}_{2}$ connects $M^{B}(1)$ and $\bm{c}_{2}$. The composition (as defined in [6]) of the three trajectories, i.e., $M=M^{A}_{1}\ast M^{B}\ast M^{A}_{2}$, then serves as a solution. Since TypeB trajectories can be reused as discuss above, they have to be computed only once and the procedure may as well be offline. This inspires us to introduce a notion of a certificate which is a set of useful TypeB trajectories. Once computed, a solution (if any) to any given bimanual manipulation query can then be constructed from the certificate in the aforementioned manner.

III-B3 Main Algorithm

First, we generate a certificate $\mathscr{M}$. This step needs to be done only once per problem setting. Given a query $Q=(\bm{T}_{s},\bm{T}_{g})$, we then extract a placement sequence $\mathscr{P}_{1}\rightarrow\mathscr{P}_{2}\rightarrow\cdots\rightarrow\mathscr{P}_{n}$, where $\mathscr{P}_{1}=\mathscr{P}_{s}$ and $\mathscr{P}_{n}=\mathscr{P}_{g}$, along with their corresponding transfer trajectories $M^{B}_{1},M^{B}_{2},\ldots,M^{B}_{n-1}$, where $M^{B}_{i}$ is a TypeB trajectory connecting the $i^{\text{th}}$ placement in the sequence to the next. Next, we generate a TypeA trajectory connecting $M^{B}_{i}$ and $M^{B}_{i+1}$ for every $i$. Finally, a solution to the query is constructed by concatenating all the trajectory (using the composition operation). Fig. 3 illustrates the proposed algorithm.

IV Generating Trajectories within

a Placement Class

In this Section, we investigate the existence of manipulation paths connecting two composite configurations in the same placement class (TypeA). The goal of this Section is to assert that given a path $\sigma:[0,1]\rightarrow SE(2)$ of the object moving from one placement to another in the same placement class, there exists a finite-length333We define the length of a manipulation path as in [6]. Generally speaking, the length is proportional to the number of necessary regrasping operations along the manipulation path. manipulation path associated with $\sigma$. In other words, the projection via $\pi_{p}$ of the manipulation path is $\sigma$. As the proof of existence itself is nonconstructive, we further propose an algorithm which, given an object path $\sigma$ together with a certain set of assumptions, will return a manipulation path associated with $\sigma$ in finite time.

IV-A *Existence of *TypeA Paths

First we introduce the notion of single-transfer connectedness as follows.

Definition 9**.**

Two composite configurations $\bm{c}_{1}$ and $\bm{c}_{2}$ are single-transfer connected if there exists a transfer path whose terminal configurations are $\bm{c}_{1}$ and $\bm{c}_{2}$.

Definition 10**.**

A single-transfer connected set $\pazocal{F}$ is a set in which any two composite configurations are single-transfer connected. If such a set is maximal in the sense that for any point $\bm{c}\in\partial\pazocal{F}$, every neighborhood of $\bm{c}$ consists of both configurations that are single-transfer connected and not single-transfer connected with $\bm{c}$, we call it a single-transfer connected component.

Let $\mathscr{F}$ be a collection of all single-transfer connected components in $\mathscr{G}\cap\mathscr{P}_{i}$. Since $\mathscr{G}\cap\mathscr{P}_{i}$ contains no singular configuration, any $\bm{c}\in\mathscr{G}\cap\mathscr{P}_{i}$ must be in some single-transfer connected component. That is, $\mathscr{G}\cap\mathscr{P}_{i}=\bigcup_{\pazocal{F}\in\mathscr{F}}\pazocal{F}$. Define $\mathscr{T}_{i}$ by $\mathscr{T}_{i}=\pi_{p}\left(\operatorname{int}(\mathscr{G}\cap\mathscr{P}_{i})\right)$. We have the following proposition.

Proposition 1**.**

Let $\sigma:[0,1]\rightarrow SE(2)$ be a path lying in a connected component of $\mathscr{T}_{i}$. Then $\sigma$ is a projection via $\pi_{p}$ of some finite-length manipulation path.

Proof.

First note that $\mathscr{T}_{i}=\bigcup_{\pazocal{F}\in\mathscr{F}}\pi_{p}\left(\operatorname{int}(\pazocal{F})\right)$. Let each projection $\pi_{p}\left(\operatorname{int}(\pazocal{F})\right)$ be denoted by $\pazocal{E}$ and $\mathscr{E}$ the collection of such sets. Since $\pi_{p}$ is an open map, each $\pazocal{E}$ is open. Therefore, $\mathscr{E}$ is an open covering of $\mathscr{T}_{i}$.

Since $\sigma$ lies entirely in some connected component of $\mathscr{T}_{i}$, there exists a subcollection $\mathscr{E}^{\prime}$ of $\mathscr{E}$ which covers $\sigma$. Let $\mathscr{I}$ be the collection of open intervals where each interval, $\pazocal{I}$, corresponds to a domain of the path $\sigma$ such that the path segment $\sigma(\pazocal{I})$ lies entirely in some open set $\pazocal{E}$.

Now we have that $\mathscr{I}$ is an open covering of $[0,1]$. Since $[0,1]$ is compact [41], there exists a finite subcollection of $\mathscr{I}$ which also covers $[0,1]$. This means that the path $\sigma$ consists of a finite number of segments where each segment lies entirely in an open set $\pazocal{E}$ and hence is a projection of a transfer path. Therefore, we can conclude that the path $\sigma$ is a projection of a finite-length manipulation path. ∎

However, since the proof of compactness of $[0,1]$ is not constructive [42], the above proposition does not give us a way to construct a finite-length manipulation path associated to a given object path $\sigma$. Note also that since the proof of Reduction Property444Reduction Property states that two configurations in the same connected component of $\mathscr{G}\cap\mathscr{P}$ are connected by some manipulation path. given in [43] also relied on the Heine-Borel covering theorem, it also does not provide a practical way to construct a manipulation path.

To explicitly construct an algorithm which, given an object path $\sigma$, computes in finite time an associated finite-length manipulation path, we need a set of additional assumptions. The idea behind the construction of the algorithm is that from the uncountable collection $\mathscr{E}$, we need to be able to extract from $\mathscr{E}$ a countable (possibly infinite) subcollection which still covers the given path $\sigma$. Then from the countable subcollection, we can then iterate through combinations of its members until we find one that covers $\sigma$. The Heine-Borel covering theorem helps guarantee that these iterations will eventually terminate in finite time.

Before we proceed to stating assumptions, we present the following result. Define the set $\pazocal{F}(g)$ as the union of all element $\pazocal{F}$ of $\mathscr{F}$ where the grasp associated with any composite configuration $\bm{c}\in\pazocal{F}(g)$ is specified by the bimanual grasp parameter vector $g$ (see Section III). Since there may exist multiple IK solutions associating with one grasp, we may categorize the set $\pazocal{F}(g)$ further into a number of subsets according to classes of the associated IK solution [44, 19]. We write $\pazocal{F}(g,k),k\in K$ to refer to the set $\pazocal{F}$ with a specific grasp $g$ and which any $\bm{c}\in\pazocal{F}(g,k)$ has the IK solution in the same class as other configurations. Note the according to [44], the index set $K$ is bounded.

Consider a set $\pazocal{E}(g,k)$, defined as the projection via $\pi_{p}$ of $\pazocal{F}(g,k)$.

Lemma 1**.**

An object path $\sigma:[0,1]\rightarrow SE(2)$ lies entirely in a connected component of $\pazocal{E}(g,k)$ if and only if it is a projection of a transfer path.

Proof.

The result follows directly from the definition of a single-transfer connected component. ∎

IV-B Assumptions

Now we present a set of assumptions as follows.

Assumption 1**.**

For any object path $\sigma:[0,1]\rightarrow SE(2)$. The intersection between $\sigma$ and the set $\pazocal{E}(g,k)$, for any grasp $g$ and IK class index $k$, consists of finitely many path segments and the domain of the path parameter for each segment is computable.

In usual manipulation planning settings, environments are relatively controlled such that they should not contain physical obstacles of extremely odd geometries which would eventually result in the set $\pazocal{E}(g,k)$ being divided into infinitely many connected components. Furthermore, the robot singularity set is not likely to divide the feasible configuration space into infinitely many connected components as well. This is true, for example, for a class of generic manipulators whose singularity sets consist of finite smooth manifolds [45]. However, the above assumption is still necessary to ensure that each connected component of $\pazocal{E}(g,k)$ is well-behaved, in the sense that a finite number of components would not result in infinitely many segments.

The second assumption is stated as follows.

Assumption 2**.**

Given an object path $\sigma$ contained in a connected component of $\pazocal{E}(g)$, where $g=\left[g_{1}^{\top}g_{2}^{\top}\right]^{\top}$, $g_{1}=[l_{1}\,a_{1}\,b_{1}\,\delta_{1}]^{\top}$, and $g_{2}=[l_{2}\,a_{2}\,b_{2}\,\delta_{2}]^{\top}$. There exists a lower bound $\epsilon>0$, which may depend on $\sigma$, such that all $\pazocal{E}(g^{\prime})$ also contain $\sigma$, where $g^{\prime}=\left[g_{1}^{\prime\top}g_{2}^{\prime\top}\right]^{\top}$, $g^{\prime}_{1}=[l_{1}\,a_{1}\,b_{1}\,(\delta_{1}+\Delta_{1})]^{\top}$, $g^{\prime}_{2}=[l_{2}\,a_{2}\,b_{2}\,(\delta_{2}+\Delta_{2})]^{\top}$, and $0<\Delta_{1},\Delta_{2}\leq\epsilon$.

This means that if the robots can grasp the object with the bimanual grasp $g$ and then trace the object path $\sigma$. The robots can also grasp the object and trace the same object path with some nearby grasps.

Now suppose, without loss of generality, that the domain of the grasp parameter $\delta$ is normalized to $(0,1)$ for each grasp class. Next, we define $\mathscr{B}(d)$, with $d=(d_{1},d_{2})\in(0,1)\times(0,1)$, as the collection of all $\pazocal{E}(g,k)$ such that the grasp parameters $\delta_{1}=d_{1}$ and $\delta_{2}=d_{2}$. Consider the set $\mathscr{A}$ defined by

[TABLE]

where $\{h_{1},h_{2},h_{3},\ldots\}$ is a two-dimensional low-discrepancy sequence, such as the sequence introduced in [46]. This set $\mathscr{A}$ is then basically an enumerate of $\mathscr{B}(d)$ at values $d$ from such a sequence. Thanks to Assumption 2, we have that there exists an integer $N$ such that the subset $\mathscr{A}^{\prime}$ of the first $N$ terms of $\mathscr{A}$ covers $\sigma$.

Assumption 3**.**

The connectivity of a set $\mathscr{T}_{i}$ for all $i$ can be determined empirically, e.g., by discretization.

The above discretization can be easily done on the three parameters $(x,y,\theta)$ parameterizing the placement. Ranges of the parameters $x$ and $y$ are determined by the user while $\theta$ ranges from [math] to $2\pi$. After obtaining the set of discretized coordinates, one tests at each point if the object is collision-free and graspable by the robots. Fig. 4(a) shows the scene in which we tested the connectivity of $\mathscr{T}_{i}$. The set $\mathscr{T}_{i}$ is visualized in Fig. 4(b) by being superimposed into the scene.

The idea here is that once the connectivity of the set $\mathscr{T}_{i}$ is determined, we can treat different connected components of $\mathscr{T}_{i}$ (if any) as different placement classes when computing a certificate. Therefore, we shall suppose in the sequel that each $\mathscr{T}_{i}$ consists of one connected component.

IV-C Algorithm

Consider next the algorithm listed in Algorithm 1. To compute a TypeA motion for to move the object along a path segment $\sigma(s),s\in[t,t^{\prime}]$ (in ComputeCCMotion line 1), one starts with the initial IK solution of the robot grasping the object at $\sigma(t)$. Note that the grasp as well as the IK solution can be determined uniquely from the element $A$. Since $[t,t^{\prime}]\subset(a,b)$, it is possible for one to use a differential IK algorithm [47] to solve for remaining IK solutions along the path (according to Lemma 1).

Based on assumptions presented in the previous Section, we have the following proposition.

Proposition 2**.**

Given an object path $\sigma$ lying entirely in $\mathscr{T}_{i}$, Algorithm 1 will terminate in finite time with a finite-length manipulation trajectory whose projection via $\pi_{p}$ is $\sigma$.

Proof.

Consider first the function Planner in Algorithm 1. Since the set $\mathscr{A}$ provides a countable open covers of the path $\sigma$, and since the closed interval $[0,1]$ of the path parameter is compact, there exists a finite subcover of $\sigma$. Therefore, only a finite number of iterations is required before the while loop (in Planner line 1) terminates. In each iteration of the while loop, one call to the function CheckCover is made. From Assumption 1 of finite intersections with $\sigma$, one would require finite time to verify intersections of each element $A$ of $\mathscr{A}^{\prime}$ with the path $\sigma$. Therefore, CheckCover always terminates in finite time.

Since $\mathscr{A}^{\prime}$ is a finite subcover of the path $\sigma$, the while loop in ComputeCCMotion will eventually terminate. This concludes the proof. ∎

V Generating Trajectories Between Different Placement Classes

It follows from Proposition 1 that if we have one TypeB trajectory which starts in some placement class $\mathscr{P}_{i}$ and ends in some other placement class $\mathscr{P}_{j}$, any pair of composite configurations in $\mathscr{P}_{i}\cup\mathscr{P}_{j}$ are also manipulation path-connected. In the case when there are only two placement classes available, any TypeB path between the two placement classes then guarantees the existence of a solution to any feasible manipulation query. With $n_{p}$ placement classes available, one only needs a minimum of $n_{p}-1$ TypeB trajectories between different pairs of placement classes in order to guarantee the existence of a solution to any feasible query. Therefore, we define the notion of a certificate as follows.

Definition 11**.**

A certificate is a set of transfer paths that spans all the placement classes.

One can think of placement classes as nodes in a graph. A certificate is then analogous to a set of edges which contains a spanning tree’s edges. Although $n_{p}-1$ transfer paths are sufficient to guarantee the existence of solutions to any manipulation query, the more transfer paths one has (between distinct pairs of placement classes) can contribute to higher quality of solutions since the system may need to visit a fewer number of intermediate placement classes before reaching the desired placement class.

Since the process of computing a certificate needs to be done only once per problem setting, we suppose that this computation can be done offline and the computation time is not a limiting factor. Therefore, one may aim at generating all ${}^{n_{p}}C_{2}=n_{p}(n_{p}-1)/2$ transfer paths connecting all possible different pairs of placement classes.

Given a pair of placement classes $\mathscr{P}_{i}$ and $\mathscr{P}_{j}$, we divide the process of generating a TypeB trajectory into two main parts:

1. generating a closed-chain query; and

2. solving a closed-chain query.

V-A Generating a Closed-Chain Query

Randomly sampling two object transformations, one from each placement class, may have a relatively low probability that the resulting closed-chain query is solvable. This is mainly due to the fact that the closed-chain constraint greatly reduces the range of motions of the system. To deal with this issue, we propose a heuristic to help generate closed-chain queries which are likely solvable. The idea behind this is that since the bimanual manipulation system can exhibit a very limited range of motions, queries should be generated such that they intuitively do not require a large range of robot motions to solve them.

Recall that object transformations in any placement class can be parameterized by three parameters (Section IV). The problem of generating closed-chain queries is then boiled down to how one generates the three parameters for the start and goal transformations. We first define a manipulation point $(x_{m},y_{m})$ on the support surface. The position parameters $(x,y)$ of the transformations to be generated will be assigned to be this point. Doing so greatly simplifies query generation while not drastically reduce the possibilities of the queries generated since the motion range of the system is already very limited. The manipulation point may be assigned to be on the middle line passing between the two robots (the green line in Fig. 5), roughly speaking, to maximize the reachability of the two robots.

Then the rotation parameter $\theta$ can be computed as follows. Let $f_{j}$ denote the face of $\pazocal{H}$ corresponding to placement class $\mathscr{P}_{j}$ (the goal placement class). Let $\bm{n}_{j}$ be a normal vector pointing outwards from the face $f_{j}$ (see the red arrow in Fig. 5(a)). The desired value of $\theta$ is such that the projection of $\bm{n}_{j}$ onto the support surface is parallel to the line $l$. The reason behind this is that once the object is arranged as mentioned, the expected closed-chain motion to move the object from placement $\mathscr{P}_{i}$ to $\mathscr{P}_{j}$ will be a relatively easy flipping motion, as shown by the blue arrow in Fig. 5(a). After the start transformation has been computed, the goal transformation can be computed accordingly (Fig. 5(b)).

Apart from the two transformations $\bm{T}_{s}$ and $\bm{T}_{g}$, we may also include into the query a grasp $g$ together with associated IK solutions at $\bm{T}_{s}$ and/or $\bm{T}_{g}$. Generating a grasp $g$ is straightforward since it can be sampled from a set of grasps available at both transformations.

Computing associated IK solutions at $\bm{T}_{s}$ and/or $\bm{T}_{g}$, however, is non-trivial when the query is to be solved via a bidirectional planner. This is because given two composite configurations in the same grasp class, there is no known way to completely determine if they belong to the same connected component of $\mathscr{G}$. Generally, one set of IK solutions of robots grasping the object corresponds to one connected component of $\mathscr{G}$ called self-motion manifold [44]. To choose IK solutions of robots grasping the object at both $\bm{T}_{s}$ and/or $\bm{T}_{g}$, we rely on an ad hoc heuristic since, to our knowledge, there is currently no known generalized way to do so.

Finally, note that this two-stage approach in generating and solving queries may proceed in iterations. If a generated query is not solvable within the given time, one can generate a new query by defining a new manipulation point, e.g., by adding some small perturbation to the point.

V-B Solving a Closed-Chain Query

Our closed-chain motion planner (CCPlanner) is adapted from a bidirectional RRT planner [35]. In particular, we build two trees $\pazocal{T}_{a}$ and $\pazocal{T}_{b}$, each one is a data structure storing vertices. A vertex $\pazocal{V}$ keeps information of a composite configuration, its parent on the tree, as well as a closed-chain trajectory connecting itself and its parent. The algorithm for CCPlanner is listed in Algorithm 2.

CCPlanner accepts the start and goal transformations, $\bm{T}_{s}$ and $\bm{T}_{g}$ and IK solutions at $\bm{T}_{s}$ and $\bm{T}_{g}$ as its inputs. It starts by initializing two trees, i.e., creating root vertices storing configuration information. In each planning iteration, CCPlanner randomly samples an object transformation matrix $\bm{T}$. Then the planner tries to extend a tree towards it. Upon a successful extension the planner tries to connect two trees together. If the connection attempt is successful, the closed-chain path is extracted from the tree and returned. Some key functions are described in details below.

• $\blacksquare$

SampleSE3: A transformation matrix (an element of $SE(3)$) is generated by separately sampling rotational and translational parts. A rotation matrix is uniformly sampled from $SO(3)$ via the method proposed in [48]. A translation vector is sampled uniformly from the user defined range.

• $\blacksquare$

Extend: To extend a tree towards a given transformation $\bm{T}$, we search in the tree the set of $k$ vertices whose transformation matrices are nearest to $\bm{T}$ (via KNN with $k$ defined by the user). The distance metric used is defined in Section III. Then for each vertex, we generate a new transformation $\bm{T}_{\text{new}}$ in the direction from $\pazocal{V}_{\text{new}}$.config.$\bm{T}$ to $\bm{T}$ such that the distance between $\bm{T}_{\text{new}}$ and $\pazocal{V}_{\text{new}}$.config.$\bm{T}$ does not exceed some pre-defined step size. Then we construct a closed-chain trajectory connecting the two transformation via Interpolate. If the trajectory generation is successful, a new vertex, $\pazocal{V}_{\text{new}}$, is created and added to the tree.

• $\blacksquare$

Interpolate: We generate an $SE(3)$ trajectory first, by using the method in [40] for the rotational part and using polynomial interpolation for the translational part. Then the trajectory is discretized into small time steps. IK solutions of the two robots are computed at each time step using the differential IK method [47].

Apart from being less complicated implementation-wise, this method gives an exact parameterization of the object trajectory. One can then incorporate various types of constraints into the object trajectory by means of time-parameterization to obtain time-optimal trajectory with respect to the constraints (see [49] for more details on time-optimal path parameterization (TOPP)). Examples of applicable constraints are velocity and acceleration limits for rigid body motions [50] and dynamic grasp stability.

Nevertheless, the user can utilize their trajectory generation method of choice. In case an exact parameterization of a closed-chain trajectory is available, one may also use the TOPP method for redundantly-actuated systems [51] (which is the case for bimanual systems) to enforce the aforementioned constraints along the trajectory.

• $\blacksquare$

Connect: After a successful tree extension, the planner will attempt to connect the newly added vertex to the other tree. The details of procedure are mainly similar to Extend, except this function does not include Threshold.

VI Experimental Results

The planner and all related functions were implemented in Python. We used OpenRAVE [52] as a simulation environment. The robots were two identical $6$-DOF industrial manipulators Denso VS-$060$. Each one was equipped with a $2$-finger Robotiq gripper $85$. The planning environment is as shown in Fig. 4. All simulations were run on a $2.4$ GHz desktop.

VI-A Computing Certificates

To validate our certificate issuing planner, we ran the planner to compute certificates for a set of objects. All objects, listed in Fig. 6, were furniture pieces which were relatively large such that they needed two robots grasping in order to move them. For each object, we repeated certificate generation for $50$ times. When computing each transfer path, we also had the following additional computations:

1. grasp equilibrium checking

2. closed-chain trajectory shortcutting ($200$ iterations).

Statistics collected from the runs are reported in Table I in “Computing Certificate” category. Here are a few things we would like to point out:

• $\blacksquare$

The planner may spend up to around $45\%$ of the total time generating and planning unsuccessful queries. This is because there currently exists no definite method to check that the generated IK solutions associated with the start and goal transformations belong to the same connected component (self-motion manifold).

• $\blacksquare$

Due to the large number of grasp classes, solving a bimanual manipulation query via, for example, the three-dimensional extension of the high-level Grasp-Placement Graph [6] could potentially be rendered infeasible. Consider Object $2$ (Fig. 6(b)), for example, which has $3$ placement classes and $51$ unimanual grasp classes. While the two-dimensional Grasp-Placement Graph has $104$ vertices and $2028$ edges, its three-dimensional counterpart contains over $3,000$ vertices with over $6$ million edges.

• $\blacksquare$

For each run, the certificate computation procedure is considered successful if the computed transfer paths span all the placement classes. Although the number of successfully planned TypeB paths varied slightly among different runs, the resulting set of TypeB paths still spanned all placement classes in every run.

• $\blacksquare$

In the current implementation, we check grasp equilibrium by solving a linear program at each discretized time step along a closed-chain trajectory. This approach is, however, time-consuming and restrictive in that it only guarantees static equilibrium555Trajectories with static equilibrium are only guaranteed to be executable at arbitrarily slow speed.. One possible improvement is by formulating contact constraints in terms of inequalities in path parameters and its derivatives [53] by utilizing cone double-description (CDD) method [54]. Then one can time-optimally parameterize the trajectory such that it moves as fast as possible while respecting all the constraints (see [49] and references therein for more details).

VI-B Solving Bimanual Queries

First, for each object listed in Fig. 6, we hand-pick two placement classes which do not have any direction connection via a TypeB trajectory (information provided by a certificate) and generated a pair of object transformations $\bm{T}_{s}$ and $\bm{T}_{g}$ from each of the placement classes. Then we repeat solving each query $Q=(\bm{T}_{s},\bm{T}_{g})$ for $50$ times. Statistics collected from the runs are reported in Table I in “Solving Queries” category. One of the main factors which causes variations in the running time is the geometry of each object. Larger objects, for example, have narrower free space to navigate on the support surface. Furthermore, with larger objects, it is also more difficult for robots to move around and change grasps.

A solution manipulation path to any of the above queries needs to be at least of length $5$. However, it is not the case here since a TypeA trajectory, which connects two TypeB trajectories from a certificate, will always contain regrasp operations. This is because the grasps used in the two TypeB trajectories are always different. Therefore, if a planner with an extension of the high-level Grasp-Placement Graph is used, it will spend a considerable amount of time invalidating manipulation paths of shorter length, hence not practical. A general manipulation planner such as a Random-MMP [30] is not likely to terminate with a solution within a reasonable amount of time as well since it needs to sample correctly a relative long sequence of transit and transfer.

Apart from the simulation results, we also successfully carried out a hardware experiment. We constructed a query for Object $2$ (Fig. 6(b)) such that there is no direct TypeB trajectory connecting the two placement classes. The scene with the start and goal transformations of the object provided by the query are shown in Fig. 7(a) and Fig. 7(f), respectively. The computed solution to this query consists of three TypeA trajectories ((a)$\rightarrow$(b), (c)$\rightarrow$(d), and (e)$\rightarrow$(f)) and two TypeB trajectories ((b)$\rightarrow$(c) and (d)$\rightarrow$(e)).

The controller used in this experiment was similar to the one presented in [2]. The video of the robots executing the motion solving this query (on the real platform) can be found at https://youtu.be/4DcMwr2xxrQ.

VII Discussion and Conclusion

VII-A Discussion

The current algorithm has some limitations. First, since the method of generating a certificate relies on a heuristic, despite its capability illustrated in our experiments, there might be cases where the method fails to produce a transfer path when there is one. To alleviate this issue, when planning a TypeB path, one might also allow intermediate placements (which does not necessarily have to be a stable one) as suggested in [2] so as to allow regrasping such that the robots can be at a configuration in the same single-transfer connected component as the goal configuration. Second, when planning a TypeA path, we currently assume that all collision-free dragging or pulling motions are feasible. This might not always be the case when the contact between the object and the support surface has very high friction and/or the robots have low maximum grip force. Future work may include investigation of effects of these issues to TypeA connectivities.

VII-B Conclusion

In this paper, we first present a set of definitions and fundamentals of bimanual manipulation planning. In order to solve a bimanual manipulation query, it is essential for the planner to obtain information of connectivities between different connected components of the composite configuration space. We propose an algorithm which constructs a manipulation solution by generating and concatenating two types of trajectories: TypeA trajectories which connect configurations in the same placement class, and TypeB trajectories which connect configurations from different placement classes. The key specificity of our algorithm is that it is certified-complete. We provide a method to compute a certificate for a given object and environment. A certificate, once obtained, guarantees that the algorithm will find a solution to any feasible bimanual manipulation query for the object in that setting in finite time. Information contained in a certificate can be used to construct a solution trajectory. Simulation and experimental results illustrate the validity and capability of our algorithm to plan bimanual manipulation motions for various practical objects.

Acknowledgment

This work was supported by Tier 1 grant RG109/14 awarded by the Ministry of Education of Singapore.