A Roadmap-Path Reshaping Algorithm for Real-Time Motion Planning

TL;DR

This paper introduces a novel real-time motion planning algorithm that combines roadmap and convex relaxation techniques, effectively generating feasible paths with curvature constraints more efficiently than existing methods.

Contribution

It proposes a new path reshaping algorithm that integrates grid-based initial path selection with curvature constraint adjustments, improving success rate and computational efficiency.

Findings

Almost surely finds a feasible path

Uses significantly less time than existing algorithms

Effectively incorporates curvature constraints

Abstract

Real-time motion planning is a vital function of robotic systems. Different from existing roadmap algorithms which first determine the free space and then determine the collision-free path, researchers recently proposed several convex relaxation based smoothing algorithms which first select an initial path to link the starting configuration and the goal configuration and then reshape this path to meet other requirements (e.g., collision-free conditions) by using convex relaxation. However, convex relaxation based smoothing algorithms often fail to give a satisfactory path, since the initial paths are selected randomly. Moreover, the curvature constraints were not considered in the existing convex relaxation based smoothing algorithms. In this paper, we show that we can first grid the whole configuration space to pick a candidate path and reshape this shortest path to meet our goal. This new algorithm inherits the merits of the roadmap algorithms and the convex feasible set algorithm. We further discuss how to meet the curvature constraints by using both the Beamlet algorithm to select a better initial path and an iterative optimization algorithm to adjust the curvature of the path. Theoretical analyzing and numerical testing results show that it can almost surely find a feasible path and use much less time than the recently proposed convex feasible set algorithm.

Tables

Table 1. TABLE I: Performance of RPR-ALL, RPR-60, and CFS in 1000 Random Configuration Spaces

Group	Method	How many configuration spaces that can be solved	Average total time (average time of finding initial paths)	The average number of waypoints.
Group1	CFS	150/200(75%)	2.17s(0s)	108
	RPR-ALL	200/200(100%)	1.75s(0.001s)	108
	RPR-60	200/200(100%)	1.46s(0.001s)	108
Group2	CFS	121/200(60.5%)	4.75s(0s)	115
	RPR-ALL	200/200(100%)	4.27s(0.001s)	115
	RPR-60	200/200(100%)	1.98s(0.001s)	115
Group3	CFS	89/200(44.5%)	13.71s(0s)	125
	RPR-ALL	200/200(100%)	10.37s(0.001s)	125
	RPR-60	200/200(100%)	2.35s(0.001s)	125
Group4	CFS	79/200(34.5%)	24.64s(0s)	129
	RPR-ALL	200/200(100%)	18.29s(0.001s)	129
	RPR-60	200/200(100%)	3.11s(0.001s)	129
Group5	CFS	33/200(16.5%)	64.87s(0s)	141
	RPR-ALL	200/200(100%)	56.8s(0.001s)	141
	RPR-60	200/200(100%)	5.93s(0.001s)	141

Table 2. TABLE II: Performance of RPR-60, and ERPR-60 in 800 Random Configuration Spaces

Group	Method	How many configuration spaces that can be solved	Average total time (average time of finding initial paths)	The average number of waypoints.
Group1	RPR-60	193/200(96.5%)	1.34s(0.001s)	115
	ERPR-60	199/200(99.5%)	28.17s(27.09s)	88
Group2	RPR-60	177/200(88.5%)	1.79s(0.001s)	129
	ERPR-60	191/200(95.5%)	13.99s(12.59s)	93
Group3	RPR-60	165/200(82.5%)	2.06s(0.001s)	137
	ERPR-60	181/200(90.5%)	8.49s(6.50ss)	98
Group4	RPR-60	139/200(69.5%)	2.70s(0.001s)	142
	ERPR-60	154/200(77%)	6.77s(3.70s)	102

Table 3. TABLE III: The Nomenclature List

Notation	Description
$𝒙$	The whole path.
${𝒙}^{\left(k\right)}$	The whole path in iteration $k$.
${𝒙}_i$	The position of the robot at $i$th time in the configuration space.
${𝒙}_i^{\left(k\right)}$	The position of the robot at $i$th time in iteration $k$.
${𝒙}_{start},{𝒙}_{end}$	The starting waypoint and the ending waypoint.
${[a_i,b_i]}^T$	The coordinates of ${𝒙}_i$.
$F\left(𝒙\right)$	The convex feasible sets.
$n+1$	The number of waypoints of the whole path.
$m$	The number of waypoints that each segment contains at most.
$O_i$	The $i$th obstacle.
$d({𝒙}_i,O_j)$	The distances between the robot and the $j$th obstacle in the $i$th time.
$d_{min}$	The minimum clearance between the robot and obstacles.
$k\times l$	The size of the roadmap.
$\delta$	The resolution level of the roadmap.
$\lambda$	Nonnegative coefficients in the objective function (1).
$\theta ({𝒙}_{i-1}-{𝒙}_{i-2},{𝒙}_i-{𝒙}_{i-1})$	The intersection angle between the vector $\left({𝒙}_{i-1}-{𝒙}_{i-2}\right)$ and $\left({𝒙}_i-{𝒙}_{i-1}\right)$.
$\theta (\overrightarrow{AB},\overrightarrow{BC})$	The intersection angle between the vector $\overrightarrow{AB}$ and $\overrightarrow{BC}$.
${\theta }_{max}$	The maximum permittable intersection angle.
$e(AB,BC)$	The arc of the beamlet graph, which connects the beamlet $AB$ and $BC$.

Equations

$$\underset{\mathbf{x}}{\max }$$

$$s.t.$$

$$d({\mathbf{x}}_i,O_j)\ge d_{min},i=0,\dots ,n,j=1,\dots ,q$$

$$f_k(\mathbf{x})\le 0,k=1,2,\dots ,s$$

$$\theta ({\mathbf{x}}_i-{\mathbf{x}}_{i-1},{\mathbf{x}}_{i-1}-{\mathbf{x}}_{i-2})\le {\theta }_{max},i=2,3,\dots ,n-2.$$

$$\underset{{\mathbf{x}}_i}{\max }$$

$$s.t.$$

$$\mathbf{x}\in F(\mathbf{x})$$

$$\displaystyle\begin{split}&c_{1}\big{[}(a_{i-2}-a_{i-1})a_{i}+(b_{i-2}-b_{i-1})b_{i}+a_{i-1}^{2}+\\ &b_{i-1}^{2}-a_{i-1}a_{i-2}-b_{i-1}b_{i-2}\big{]}+\big{\lvert}(a_{i-1}-a_{i-2})b_{i}\\ &-(b_{i-1}-b_{i-2})a_{i}+b_{i-1}a_{i-2}-b_{i-2}a_{i-1}\big{\rvert}\leq 0\end{split}$$

Full text

I Introduction

Motion planning refers to the problem of finding a collision-free and dynamically-feasible path between the pre-specified starting configuration and the goal configuration in obstacle-cluttered environments [1], [2]. Since it is often hard to achieve both collision-free and smooth paths simultaneously, we usually decompose the problem into two stages: first finding a collision-free path and then smoothing it [3].

There were various roadmap algorithms [4] -[9] to compute collision-free paths. These algorithms first determine the free space and then find the collision-free paths characterized by a few waypoints within the free space. However, it is difficult for roadmap algorithms to simultaneously satisfy both dynamic constraints and exploring the configuration space. Their returned paths tend to be unsmooth and may have sharp turns.

To make the path more suitable for mobile robots, researchers proposed different path smoothing algorithms [10]-[11] which can be divided into three kinds: interpolation-based, shortcut, and optimization-based algorithms [3], [12], [13].

Interpolation-based algorithms attempt to relocate waypoints to fit some types of curves (e.g., polynomial curve [14], spline [14], or NURBS curve [15]) that have good smoothness. Shortcut algorithms [16] check and replace the jerky portions of a path with some transition curves (e.g., Dubin’s curve [17], clothoid [18], or hypocycloid [19]). However, both the two kinds of algorithms restrict the moving scopes of the waypoints and cannot significantly change the shape of the whole path.

In contrast, optimization-based algorithms allow waypoints to move significantly away from their original locations. For example, the Convex Elastic Smoothing (CES) algorithm [3] uses a set of ”bubbles” along the initial path to approximate the free space and let the waypoints to move within these ”bubbles”. Then, the CES algorithm solves two convex optimization problems alternately for path smoothing or speed optimization. Furthermore, the Convex Feasible Set (CFS) algorithm [20] -[23] uses the intersection of convex cones to define a larger free space and leads to a faster convergence speed. To distinguish optimization-based algorithms from interpolation-based and shortcut algorithms, we would like to call their iteration process as ”path reshaping” rather than ”path smoothing”.

However, many optimization-based algorithms neglect the selection of the initial path and just choose a random path to start. As a result, these algorithms often fail to give a valid path, because the properties of the final path still highly depend on the initial path in optimization-based algorithms, although we have assigned the path more deformation capability.

To solve this problem, we propose a new algorithm to generate collision-free and smooth paths by combining the merits of the roadmap algorithm and the path reshaping algorithm. Specifically, we first grid the whole configuration space and dilate obstacles to find an appropriate initial path by Dijkstra’s algorithm [24]. Then, we apply the CFS algorithm to reshape it. Gridding the configuration and dilating obstacles can guarantee the existence of a feasible final path and also help reduce the time cost of reshaping. To further accelerate our algorithm, we propose a modified algorithm by using the divide-and-conquer strategy. We adopt the Beamlet algorithm [25] to further select an initial path that is more suitable for the given curvature constraints. We also design an iterative optimization algorithm to adjust the path to rigorously meet the curvature constraints.

Numerical testing results show that our proposed algorithm can almost surely find a feasible path and requires less computation time, if compared to the CFS algorithm. To give a detailed explanation of our finding, the rest of this paper is organized as follows. Section II formulates the motion planning problem as an optimization problem and then introduces the CFS algorithm as a basis for further discussions. Section III presents our new algorithm, proves its feasibility, and explains its time complexity. Section IV further discusses how to handle curvature constraints for the initial and final path. Section V presents some numerical testing results to validate our new algorithm. Finally, Section VI concludes the paper.

II Problem Formulation

II-A The Optimiaztion Problem

Our goal is to find a path $\boldsymbol{x}$ that is characterized by a series of $(n+1)$ waypoints, i.e. $\boldsymbol{x}=[\boldsymbol{x}_{0}^{T},\boldsymbol{x}_{1}^{T},\dots,\boldsymbol{x}_{n}^{T}]^{T}$, where $\boldsymbol{x}_{i}\in\mathbb{R}^{2}$ represents the position of the robot at $i$th time in the configuration space.

In this paper, the robotic motion planning problem is formulated as the optimization problem (1)-(4) as below.

[TABLE]

where $\boldsymbol{x}_{start},\boldsymbol{x}_{end}\in\mathbb{R}^{2}$ are the starting waypoint and the ending waypoint, respectively, and $O_{1},O_{2},\dots,O_{q}\in\mathbb{R}^{2}$ denote $q$ obstacles in the configuration space. The distances between the robot and the $j$th obstacle in the $i$th time is denoted as $d(\boldsymbol{x}_{i},O_{j})$. $d_{min}$ is the minimum clearance between the robot and obstacles.

The objective function (1) is typically designed as a quadratic function, where the matrices $\boldsymbol{V}\in\mathbb{R}^{2n\times 2(n+1)}$, $\boldsymbol{A}\in\mathbb{R}^{2(n-1)\times 2(n+1)}$ are pre-defined weighting matrices [20] that indicate the need to reduce the path length and acceleration/deceleration values of the path, respectively, and $\lambda\in\mathbb{R}^{+}$.

The major difficulty of the above optimization problem lies in its nonconvex constraints (3) that are designed for obstacle avoidance and its intricate constraints (4) on robots’ dynamic. In this paper, we will first present how to handle the problem when constraints (3) alone are considered and then discuss how to solve the problem when both constraints (3)-(4) are considered.

II-B The Convex Feasible Set Algorithm

The CFS algorithm proposed in [20] -[23] assumes that every two consecutive waypoints are linked with line segments to form a piecewise linear path that connects the starting waypoint and the ending waypoint. Given the initial path, these waypoints will be adjusted in an iterative way so that the final path is feasible for the above constraints (2)-(3) and meanwhile minimize objective (1). This setting is similar to the Convex Elastic Smoothing (CES) algorithm.

The difference lies in the setting of the local collision-free feasible regions in which the waypoints can be adjusted. The CES algorithm assumes that a sequence of ”bubbles” is placed along the reference path to identify the local feasible region. In contrast, the CFS algorithm assumes the local feasible regions are the intersection of convex cones that can be found online. This new setting is less conservative and only add a few more computation costs.

The complete CFS algorithm can be summarized as Algorithm 1 below. More details can be found in [20].

However, testing results indicate that the CFS algorithm may fail to provide sufficient free spaces to reshape the path to avoid obstacles, if the initial path is inappropriately chosen, as shown in examples of Section V-A. Existing literature [20]-[23] neither discussed how many waypoints are needed for a particular problem, nor provided a way to set the initial path $\boldsymbol{x}^{(0)}=[\boldsymbol{x}_{0}^{(0)T},\boldsymbol{x}_{1}^{(0)T},\dots,\boldsymbol{x}_{n}^{(0)T}]^{T}$ to guarantee that we could find a feasible path finally.

III The Roadmap-Path Reshaping Algorithm

III-A The Basic Idea

Inspired by the roadmap algorithms for path planning, we propose a new algorithm that can be roughly described as follows:

First, uniformly grid the whole configuration space with a resolution level $\delta$ that is sufficiently small to guarantee the existence of a feasible path. Each intersection point of two gridlines will be taken as a node of the roadmap graph. Each line segment between two neighboring nodes will be taken as an arc of the roadmap graph, if neither of its two nodes is within the obstacles; see Fig.1 for an illustration.

Second, pick the shortest path in the roadmap graph as the initial path, using Dijkstra’s algorithm.

Third, apply the CFS algorithm to reshape the initial path until we reach the final path.

In this paper, each obstacle is approximated by square grids to reduce the calculation costs of convex feasible sets of the CFS algorithm. Especially, each obstacle is first dilated to fill the grids (dark blue in Fig.1) that are overlapped with this obstacle and further dilated at least $\lceil d_{min}/\delta\rceil\delta$ (light blue region in Fig.1) to meet the condition of minimum safety distance $d_{min}$, where $\lceil d_{min}/\delta\rceil\delta$ represents the smallest integer not less than $d_{min}/\delta$. Because the size of each grid is small enough, the size of each obstacle is not overestimated much.

In the rest of this paper, we refer to the dilated obstacles (the light blue region in Fig.1) as the ones that we need to detour. It is worth noting that the distances from the initial waypoints (black dots in Fig.1) to dilated obstacles are at least $\delta$, since every node of arcs in the roadmap graph is outside dilated obstacles. This setting guarantees the existence of nonempty convex feasible sets; see discussions below.

To prove that this new algorithm can guarantee to find a feasible path, we prove the following theorem based on Lemma 1 below.

Lemma 1** (Theorem 1 in [20])**

For every initial path whose convex feasible sets have nonempty interiors, the CFS algorithm will converge to a strong local optimum or weak local optimum of the optimization problem (1)-(3).

Theorem 2

If the whole configuration space is gridded with a sufficient small resolution level and obstacles are dilated as mentioned above, there must exist nonempty convex feasible sets for each waypoint of the initial path $\boldsymbol{x}^{(0)}=[\boldsymbol{x}_{0}^{(0)T},\boldsymbol{x}_{1}^{(0)T},\dots,\boldsymbol{x}_{n}^{(0)T}]^{T}$ found by Dijkstra’s algorithm.

Proof:

We prove it by contradiction. Suppose the convex feasible sets $F(\boldsymbol{x}^{(0)})=\emptyset$, there exists a waypoint $\boldsymbol{x}_{i}^{(0)}$ with $F(\boldsymbol{x}_{i}^{(0)})=\emptyset$ at least. Without loss of generality, we assume that $\boldsymbol{x}_{i}^{(0)}$ does not lie in the boundaries of the configuration space. The situation where $\boldsymbol{x}_{i}^{(0)}$ locates at the boundaries can be proved similarly.

As the intersection point of two gridlines that are not boundaries, $\boldsymbol{x}_{i}^{(0)}$ is the common vertex of four grids, as shown in Fig.2. Due to $F(\boldsymbol{x}_{i}^{(0)})=\emptyset$, there will exist dilated obstacles in an arbitrarily small neighborhood \Big{\{}\boldsymbol{x}\Big{\lvert}\big{\lVert}\boldsymbol{x}-\boldsymbol{x}_{i}^{(0)}\big{\rVert}\leq\epsilon\Big{\}} of $\boldsymbol{x}_{i}^{(0)}$.

Since $\boldsymbol{x}_{i}^{(0)}$ is a node of some arc in the roadmap graph, whose distance to the closest dilated obstacle is at least $\delta$, we can assert that the four neighboring grids connecting $\boldsymbol{x}_{i}^{(0)}$ do not contain dilated obstacles at all. This contradicts the aforementioned result that at least one grid of the four grids contains dilated obstacles. Therefore, we have $F(\boldsymbol{x}^{(0)})\neq\emptyset$. ∎

III-B Time Complexity Analysis and a Modified Algorithm

It is apparent that the time cost of this new algorithm consists of two parts. The first part comes from the calculation of the obstacle dilation and finding the shortest path. The second part comes from the iteration of the CFS algorithm.

Suppose we obtain $k\times l$ grids for the configuration space (that is, a roadmap graph with $k\times l$ nodes and $4k\times l$ arcs) and the found shortest path contains $(n+1)$ waypoints. Generally, for a rectangle configuration space, $(n+1)$ should be at the same order of $\sqrt{k\times l}$. The average time complexity for Dijkstra’s algorithm to find the shortest path in this roadmap graph is O\big{(}(k\times l)\textrm{log}(k\times l)+4k\times l\big{)}. The dilation time cost is relatively small and is thus omitted here.

With $(n+1)$ waypoints, we have $2(n+1)$ decision variables for the optimization problem (1)-(3). If we use the interior-point method [25] (e.g., Mehrotra-type predictor-corrector algorithm [26] used in MATLAB), the average time complexity of solving the optimization problem (1)-(3) should be O\big{(}16(n+1)^{4}\lvert\textrm{log}(\epsilon)\rvert\big{)} [26], with the precision requirement $\epsilon$.

It is hard to predict how many iterations are needed for the CFS algorithm to converge. However, we can see that the time complexity of the whole algorithm is dominated by the time complexity of the CFS algorithm.

A further look shows that the CFS algorithm may works slowly if the number of waypoints in the initial path is too large. To solve this problem, we propose a modified algorithm that uses the divide-and-conquer method.

Beginning from the first waypoint, we divide the whole initial path into segments of every $m$ waypoints. With $(n+1)$ initial waypoints, we will have $\lceil(n+1)/m\rceil$ segments in the path and we will reshape each segment by using the CFS algorithm, respectively.

This simple trick may fail, since there might exist some sharp turns around the boundary points of these segments. To avoid the abrupt changes of speed caused by these sharp turns, we append an extra constraint that the velocities of boundary points should be equal for two consecutive segments, as the velocities of their predecessors when using the CFS algorithm to reshape every segment. However, this additional constraint sometimes makes the CFS algorithm unable to obtain a feasible segment.

Fig.3a provides an intuitive illustration. In Fig.3a, $\boldsymbol{x}_{j}$ is a boundary point, $\boldsymbol{x}_{j-1}$ and $\boldsymbol{x}_{j+1}$ are its predecessor and successor waypoint, respectively. Since the speed of $\boldsymbol{x}_{j-1}$ is $[\delta,0]^{T}$ in Fig.3a, the speed of $\boldsymbol{x}_{j}$ will be also set as $[\delta,0]^{T}$ according to the extra constraint. Moreover, because the distance from $\boldsymbol{x}_{j}$ to the obstacle along the speed direction of $\boldsymbol{x}_{j}$ is exact $\delta$, the continuity requirement of speed will drive $\boldsymbol{x}_{j+1}$ to lie in the boundary of the obstacle, and the following waypoints will be inside the obstacle.

To solve this problem, we can select two waypoints $\boldsymbol{x}_{j-\lceil m_{1}/2\rceil}$ and $\boldsymbol{x}_{j+\lceil m_{2}/2\rceil}$ as new boundary points to replace $\boldsymbol{x}_{j}$, where $m_{1}$ and $m_{2}$ are the number of waypoints in two segments that connect $\boldsymbol{x}_{j}$, respectively, as shown in Fig.3b. If the boundary point still does not work, we can repeat such boundary point alternation until that the CFS algorithm obtains a feasible final segment. With the aid of the boundary point alternation, the CFS algorithm will have a larger probability (may not always 100%) to obtain a feasible segment.

The modified algorithm can be summarized as Algorithm 2 below. Testing results show that the modified algorithm usually works in practice. In the below, we use the abbreviation RPR-m to refer this algorithm with at most $m$ waypoints in a segment.

We generally neglect the time cost of the boundary point alternation due to the low probability of occurrence. Thus, the modified algorithm usually solves $(n+1)/m$ optimization subproblems (1)-(3) with $2m$ decision variables for each subproblem (assume that $(n+1)/m$ is an integer). The time complexity of solving each subproblem is O\big{(}16m^{4}\lvert\textrm{log}(\epsilon)\rvert\big{)}. Therefore, the total time complexity should be O\big{(}16m^{3}(n+1)\lvert\textrm{log}(\epsilon)\rvert\big{)}, which is much less than the complexity of directly solving the original optimization problem with $2(n+1)$ decision variables.

IV Further Discussions On Curvature Constraints

Different with the CFS algorithm, our new algorithm can be further extended to explicitly consider the curvature constraints between two consecutive waypoints

[TABLE]

where $\theta(\boldsymbol{x}_{i}-\boldsymbol{x}_{i-1},\boldsymbol{x}_{i-1}-\boldsymbol{x}_{i-2})$ represents the intersection angle between the vector $(\boldsymbol{x}_{i}-\boldsymbol{x}_{i-1})$ and $(\boldsymbol{x}_{i-1}-\boldsymbol{x}_{i-2})$, and $\theta_{max}$ is the maximum permittable intersection angle.

IV-A Considering Curvature Constraints at Roadmap Step

The first extension is to handle the curvature constraints in the roadmap step by applying the Beamlet-based Dijkstra’s algorithm [27], named the Beamlet algorithm, instead of Dijkstra’s algorithm to find the initial path.

Beamlets refer to the line segments (e.g., the line segment AB in Fig.4) connecting certain points located at the boundaries of dyadic squares. A dyadic square [28] (d-square, e.g., the red squares in Fig.4) is a set of points in a square region with pre-specified size. A d-square may be further partitioned into four sub-d-squares of the same size to guarantee that beamlets constructed on these d-squares do not pass through obstacles.

In this paper, we select the gridlines of the roadmap constructed in Algorithm 2 as the boundaries of dyadic squares. Furthermore, the nodes of the roadmap that locate at the boundaries of dyadic squares are taken as endpoints of beamlets.

We can further construct a beamlet graph by linking a series of beamlets, with respect to the given curvature constraints. The intersection angle between the beamlet AB and the beamlet BC is defined as the intersection angle between the vector $\overrightarrow{AB}$ and $\overrightarrow{BC}$ ($\theta(\overrightarrow{AB},\overrightarrow{BC})$), i.e. $\theta$ in Fig.4. In a beamlet graph [28], an arc $e(AB,BC)$ exists from the beamlet AB to the beamlet BC, if and only if they are connected and $\theta(\overrightarrow{AB},\overrightarrow{BC})\leq\theta_{max}$. Notably, the length of $e(AB,BC)$ is set as the length of the beamlet BC.

The Beamlet algorithm first constructs a beamlet graph based on the original roadmap in Algorithm 2 and then uses Dijkstra’s algorithm on the beamlet graph to find an initial path. More details can be found in [27] -[28].

Notably, if some beamlet is too long, the distance between corresponding waypoints (the endpoints of the beamlet) may be also too large. To balance the distance between consecutive waypoints, we suggest inserting extra waypoints along the initial path found by the Beamlet algorithm.

IV-B Considering Curvature Constraints at Reshaping Step

The second extension is to use an iterative optimization algorithm to make a given path rigorously meet the curvature constraints.

Specifically, in this paper, we only consider the situation where $\theta_{max}<\frac{\pi}{2}$. Denoting $\boldsymbol{x}_{i}=[a_{i},b_{i}]^{T}$, we iteratively solve the following optimization problem (6)-(9) to sequentially check and modify every waypoint $\boldsymbol{x}_{i}$ while fixing other waypoints $\boldsymbol{x}_{j},j\neq i$, until the whole path meets these constraints or the number of modification is over a pre-specified value; see Fig.5 for an illustration.

Since only $\boldsymbol{x}_{i}$ is modified and other waypoints are unchanged, the constraint (9) becomes convex. Consequently, the obtained optimization problem (6)-(9) is convex.

[TABLE]

where $F(\boldsymbol{x})$ is the convex feasible set and $c_{1}=\textrm{tan}\theta_{max}$. The constraint (9) is equivalent to $\textrm{tan}~{}\theta_{i}\leq c_{1},~{}i=2,3,\dots,n-2$.

Our extended algorithm can be summarized as Algorithm 3 below. In the below, we use the abbreviation ERPR-m to refer this extended algorithm with at most $m$ waypoints in a segment.

IV-C Time Complexity Analysis

It is apparent that Algorithm 3 has two additional time costs than Algorithm 2.

First, Algorithm 3 applies Dijkstra’s algorithm on the beamlet graph to find the initial path. According to [27], with $k\times l$ nodes in the roadmap, there will be O\big{(}\frac{1}{2}(k\times l)\textrm{log}_{2}(k\times l)\big{)} nodes and O\Big{(}\frac{1}{4}(k\times l)^{2}\big{(}\textrm{log}_{2}(k\times l)\big{)}^{3}\Big{)} arcs in the beamlet graph that is based on the roadmap. Therefore, the time complexity for Dijkstra’s algorithm to find initial paths on the beamlet graph is O\Big{(}\frac{1}{4}(k\times l)^{2}\big{(}\textrm{log}_{2}(k\times l)\big{)}^{3}\Big{)}, which can be rewritten as O\Big{(}2(n+1)^{4}\big{(}\textrm{log}_{2}(n+1)\big{)}^{3}\Big{)}, since $k\times l$ is at the same order of $(n+1)^{2}$, the square of the number of waypoints, for rectangle configuration spaces. Here we ignore the complexity of constructing the beamlet graph, since it is much less.

Second, Algorithm 3 needs to check and modify each waypoint, corresponding to solving the additional optimization problem (6)-(9). We still assume that Mehrotra-type predictor-corrector algorithm is used to solve it, whose average time complexity is O\big{(}n^{4}\lvert\textrm{log}(\epsilon)\rvert\big{)} if there are $n$ decision variables and the precision requirement is $\epsilon$. Since the optimization problem (6)-(9) only has 2 decision variables, the complexity of modifying a waypoint is O\big{(}16\lvert\textrm{log}(\epsilon)\rvert\big{)}. If the path has totally $(n+1)$ waypoints, then the complexity of modifying the whole path is O\big{(}16(n+1)\lvert\textrm{log}(\epsilon)\rvert\big{)}.

V Numerical Tesing Results

V-A Comparison between the CFS and the Algorithm 2

In this subsection, the performance of Algorithm 2 (RPR-m algorithm) is compared with the original CFS algorithm on random configuration spaces.

We restrict the whole configuration space in a rectangular region whose length and width are 9 and 6, respectively, and set up a coordinate system as shown in Fig.6. In addition, we set $d_{min}=0.1$ and discretize the configuration space into $60\times 90$ grids with the resolution level $\delta=0.1$.

We randomly place non-overlapping rectangular obstacles in the configuration space [29], whose position satisfies the 2D uniform distribution in the configuration space and aspect ratio satisfies the 1D uniform distribution in the interval [1/2.5,2.5]. The area of the $i$th rectangle is set as $A_{0}/i^{1.1}$ [29], where $A_{0}$ is pre-specified to guarantee that these rectangles can fill the whole configuration space if their number is infinite.

For the motion planning problem (1)-(3), we set $\lambda=1$, $\boldsymbol{x}_{start}=[0,0]^{T}$, $\boldsymbol{x}_{end}=[9,0]^{T}$. The other parameters of the RPR-m algorithm and the original CFS algorithm are set as follows:

• •

The RPR-m algorithm. We set $m=60$, considering the capability of our computer and the fact that a small $m$ might make the CFS algorithm inefficient because there are too many segments to reshape. We refer to it as RPR-60. Specially, we also use the abbreviation RPR-ALL to refer our algorithm that uses the CFS algorithm directly reshape the whole path without any segments.

• •

The original CFS algorithm. We set its initial path as the line segment bounded between the starting point and the ending point, and set $(n+1)$, the number of waypoints, to be equal as the number of waypoints of the initial path in the RPR algorithm.

We compare the performance of the RPR algorithm (including both RPR-ALL and RRP-60) and the original CFS algorithm in the following two criteria.

The probability to find a feasible path. 2. 2.

The computation time of the algorithm.

To avoid bias caused by occasionality, we randomly generated 1000 configuration spaces, which can be divided into 5 groups. There are 200 configuration spaces in each group. The configuration spaces in each group contain 5, 10, 15, 20, and 30 obstacles, respectively.

All numerical experiments were performed on a computer with an Intel(R) Core (TM) i7-7700U CPU and 8GB RAM. The RPR algorithm and the original CFS algorithm were implemented in MATLAB2016b. We implement the CFS algorithm according to Liu [30]. The main differences between our code and Liu’s code are that we add additional constraints to strict paths in the configuration space and the relative optimization problems were solved by CVX [31].

Table.I shows the detailed results of these algorithms. The third column of Table.I shows the number and the percentage of problems that have been solved successfully by each algorithm, respectively. Clearly, both RPR-ALL and RPR-60 can find a feasible path with 100% probability; while the original CFS algorithm fails to do so especially when the number of obstacles is large.

The fourth column of Table.I shows the average computation time of each algorithm. In particular, the numbers in parentheses represent the average computation time of finding initial paths. Since the initial path of the original CFS algorithm is the line segment bounded between the starting point and the ending point, we assume that its computation time is zero. For every group, the computation time for the RPR-ALL algorithm and the RPR-60 algorithm to find initial paths is nearly zero. Moreover, the RPR-ALL algorithm converges slightly faster than the original CFS algorithm but much slower than the RPR-60 algorithm. This is mainly caused by the proper partition of the whole path which may lead to a noticeable reduction of time costs.

The fifth column of Table.I shows the average number of waypoints in each group. It is obvious that the number of waypoints tends to increase as the number of obstacles increases, which is consistent with the intuition that more complicated environments usually lead to longer trajectories.

To provide an intuitive illustration, Fig.6a and Fig.6b show an example of the final paths computed by the RPR-60 algorithm and the original CFS algorithm, respectively. We can see that the RPR-60 algorithm successfully found a feasible and smooth final path, while the original CFS algorithm failed.

In summary, compared to the original CFS algorithm, the RPR algorithm requires less computation time and can almost surely find a feasible and smooth path.

V-B Comparison between the Algorithm 2 and the Algorithm 3

In this subsection, we compare Algorithm 3 (ERPR-m algorithm) with Algorithm 2 (RPR-m algorithm) in the perspective of the probability to find feasible paths that meet the curvature constraints (5).

We still adopt the rectangular configuration spaces with the same size as the last subsection and set up the same coordinate system as shown in Fig.7. The configuration space is also discretized into $60\times 90$ grids with the resolution level $\delta=0.1$ and $d_{min}=0.1$.

Here we randomly generate non-overlapping circular obstacles, whose position satisfies the 2D uniform distribution in the configuration space. The area of the $i$th circle is also set as $A_{0}/i^{1.1}$.

For the RPR-m algorithm, we set $m=60$; for the ERPR-m algorithm, we set $\theta_{max}=30^{\circ}$ and $m=60$. And we set “maxiter” of the ERPR-m algorithm as the number of waypoints, thus we can modify every waypoint in the path. The other parameters are the same as the last subsection.

We randomly generated 800 configuration spaces that are divided into 4 groups. There are 200 configuration spaces in each group, which contain 5, 10, 15, and 20 obstacles, respectively.

Table.II shows the detailed results of the two algorithms. The third column of Table.II shows the number and the percentage of problems that have been solved successfully by two algorithms, respectively. We can see that the ERPR-60 algorithm always has a larger probability to find feasible paths that meet curvature constraints, if compared to the RPR-60 algorithm. Of course, the probability for both the RPR-60 algorithm and the ERPR-60 algorithm to find feasible paths decreases as the number of obstacles increases.

The fourth column of Table.II shows the average computation time of each algorithm, where the numbers in parentheses represent the average computation time of finding initial paths. We can see that the average time for the ERPR-60 algorithm to reshape initial paths is similar to the corresponding time needed by the RPR-60 algorithm; while ERPR-60 algorithm requires more time to find initial paths. This is consistent with our previous time complexity analysis, since the complexity of the Beamlet algorithm is O\Big{(}2(n+1)^{4}\big{(}\textrm{log}_{2}(n+1)\big{)}^{3}\Big{)}, while the complexity of Dijkstra’s algorithm used in RPR-60 algorithm is O\big{(}(k\times l)\textrm{log}(k\times l)+4k\times l\big{)} (i.e. O\big{(}2(n+1)^{2}\textrm{log}(n+1)+4(n+1)^{2}\big{)}). The increase in computation time is acceptable, especially for cluttered configuration spaces, such as Group4, if we would like to increase the probability to find feasible paths.

Besides, we can see that the computation time for the Beamlet algorithm to find initial paths reduces with the number of obstacles increasing. As the number of obstacles increases, the total areas of d-squares that do not contain obstacles decreases, which contributes to a reduction in the number of the nodes and the arcs in the beamlet graph. Therefore, the time of finding initial paths on the beamlet graph reduces.

The fifth column of Table.II shows the average number of waypoints in each group. Obviously, the number of waypoints increases as the number of obstacles increases.

To provide an intuitive illustration, Fig.7a and Fig.7b show an example of the final paths found by the RPR-60 algorithm and the ERPR-60 algorithm, respectively. We can see that the ERPR-60 algorithm successfully found a feasible and smooth path that met the curvature constraints, while the final path found by the RPR-60 algorithm in Fig.7a is infeasible because there exists a sharp turn with a large angle, as shown in Fig.7a.

VI Conclusion

Compared to the recently proposed CFS algorithm, our algorithm has a larger probability to find feasible paths that meet specific requirements, such as the curvature constraints, and achieves a great reduction in computation time. The key elements that contribute to the success of our algorithm stem from combining roadmap algorithms and the optimization-based path reshaping algorithms. Roadmap algorithms serve to find paths for discrete problems via rough but fast exploration, while the optimization-based path reshaping algorithms are designed to compute paths for continuous problems via refined and local adjustment. Therefore, combining the two kinds of algorithms can effectively balance the breadth and the depth of the search.

With the curvature constraint considered, the computation time will increase. This is reasonable and acceptable, as the old saying goes, “A beard well lathered is half shaved”.

In this paper, we simplify the shape of the robot into a single point, which is reasonable if the robot is much smaller than obstacles. However, in many applications, such as autonomous driving, the size of the robot is close to, even larger than the size of obstacles. In these situations, the shape of the robot should be considered, which will be handled in our future research.

The main notations presented in this paper are summarized in the following Table.III.