1. Introduction
With the rapid advancement of science and technology, robotics has become widely applicable in various fields, including industrial automation, the service industry, and medical assistance. Robot navigation, which underpins autonomous movement and task execution, remains a core focus within robotics. Path planning is a critical component of robot navigation, addressing the design of an optimal and effective route for robots to travel from a starting point to a destination within complex environments. Effective path planning enhances mobility efficiency, ensures safety, and reduces energy consumption.
In the real world, the terrain where path planning occurs is often non-uniform. Different terrains and materials result in varying costs for the same distance traveled by a robot. For instance, the robot pays a higher cost when passing through terrain with water than when passing through smooth terrain. Additionally, due to specific task requirements and the robot’s motion characteristics, the generated path must adhere to several constraints and be sufficiently smooth to avoid additional costs and risks. In practical applications, robots often need to traverse a series of landmark points to fulfill specific requirements, such as picking up goods or refueling. Due to system control and dynamic factors, short line segments between curves can introduce excessive turns, complicating control and making it difficult to manage acceleration, deceleration, or steering. This can amplify errors, causing the path to deviate from the target and incurring additional costs and risks. Referring to
Figure 1, we divide the line segments between the curves into two categories for discussion, namely the co-direction curves and the reverse curves. Similarly, if the maximum curvature of the curve is not limited, when the robot exceeds the maximum curvature limit that the steering system can withstand, it will not only deviate from the route but also cause wear and tear of the equipment. To ensure the path’s feasibility, we impose constraints on the minimum length of line segments between curves and the maximum curvature of the curves while the path is reasonable. The goal of this paper is to find a low-cost, curvature-continuous path on a cost-assigned map that passes through all given landmark points, avoids obstacles, and satisfies the constraints of the minimum length of line segments between curves and the maximum curvature of the curve.
Classic path planning algorithms, such as Dijkstra’s Algorithm and A*, are effective in many cases but typically assume that the path is composed of straight segments, without considering path curvature. Methods that use splines to generate a smooth path, like Bezier curves, may not always align with the robot’s motion characteristics and rely on added control points to meet the obstacle avoidance requirements, leading to potential route deviations and errors. Line segments and circular curves offer significant advantages in path planning, facilitating easier control and smoother turns for robots, reducing wear and tear, and maintaining stability. A clothoid is a curve with continuously changing curvature. Its predominant characteristic is that the curvature of a point on the curve is proportional to the distance moved along the curve to that point. This design helps robots better follow the predetermined path, enhancing accuracy, work efficiency, and precision while minimizing control errors from sudden curvature changes. This paper explores a novel path planning method through mathematical modeling to generate a smooth path that better aligns with actual task requirements and the machine’s motion characteristics while considering costs. We first define a mathematical model that meets specific needs and constraints, and based on this, propose a two-stage algorithm. In the first stage, the graph structure is constructed by generating points on the map, and we use Dijkstra’s Algorithm to obtain the connection order of the landmark points; the second stage builds on the previous stage and deals with landmark points one by one, and then the key points of the path are generated by using the Smooth Beacon Reconnection (SBR) algorithm proposed by us. Finally, the low-cost path that meets the requirements is obtained after fine tuning.
This study makes significant contributions in the following aspects:
Addressing the limitation of traditional algorithms that fail to consider walking costs associated with terrain and materials, our proposed algorithm is capable of generating an economically viable route on a cost map.
Overcoming the drawbacks of conventional algorithms where smooth paths comprise multiple smooth paths, our algorithm seamlessly transitions between line segments and arcs through the clothoid to ensure overall path curvature continuity.
The proposed mathematical model considers the dynamic factors of the robot and the accuracy requirements of system control, incorporating constraints such as the minimum length of line segments between curves and the maximum curvature of the curve.
The algorithm we propose takes into consideration real task landmark points and obstacle avoidance requirements, ensuring that the path passes through all specified points while avoiding obstacles. Experimental evaluations are conducted on maps in various common scenarios to assess its performance.
Through comparison with traditional researches, it is evident that the new method closely aligns with real-world needs, demonstrating its superiority in smooth path planning.
This paper consists of six sections, which is arranged as follows: In
Section 2, we review the related work, including the research progress of traditional path planning algorithm and smooth path. In
Section 3, we first introduce the basic concept of clothoid and some basic constraints of the problem, then give a method of completing the transition between line segment and arc through clothoid, and finally put forward the mathematical model of the problem studied in this paper.
Section 4 describes the proposed two-stage algorithm based on global coarse search and local optimization, thereby achieving the decoupling solution of decision-making and geometric constraints for the problem.
Section 5 describes the experimental environment, explains the experimental parameters, and further proves the rationality and efficiency of the algorithm through the analysis results. In the last
Section 6, we summarize the paper, point out the deficiencies of the current work and give the direction of future work.
2. Related Work
Path planning (PP) is gradually becoming more crucial in the field of autonomous mobile robots. So far, many algorithms have been used to solve this problem. The algorithm proposed by Dijkstra E.W. [
1] is one of the classic algorithms. It continuously updates the shortest path distance between the node and the starting point to find the shortest path; The A* algorithm [
2] uses a heuristic function that combines the actual cost and the estimated cost to measure the cost to the target node, and gives priority to low-cost nodes during the search process. These two methods lack curvature continuity, rendering them unsuitable for robot control where abrupt directional changes induce instability and mechanical wear. Building upon the A* algorithm, Sun et al. [
3] enhanced its efficiency by reducing unnecessary operations on the open list, yet their approach still inherits these limitations. Harabor and Grastien [
4] proposed the JPS algorithm which expands the points added to the OpenList based on the strategy of searching for jump points, aiming to optimize the operation of searching for successor nodes. Their work can place the map cost within the graph structure, but ignores the curvature constraints. The algorithm proposed in this paper integrates the advantages of the classical graph search algorithms, such as fast running speed and cost consideration, and generates smooth paths that meet the conditions by finding key points.
Different from the graph search algorithm running on a given graph structure, the Sampling-Based Planning (SBP) algorithm also widely used due to its property of probabilistic completeness, i.e., a solution will be provided, if one exists, given infinite runtime [
5,
6]. The most classic algorithm is the RRT algorithm proposed by LaValle S. [
7], which searches for paths by randomly sampling in space and gradually building a tree structure. Based on the RRT algorithm that searches for path by randomly sampling in space and gradually constructing a tree structure, the RRT* algorithm proposed by Karaman and Razzoli [
8] enhances the path quality through rewiring and neighborhood search, and proves the asymptotic optimality of the algorithm, but there may be no solution in the short time; Nasir et al. [
9] improved the convergence speed of this algorithm through intelligent sampling and path optimization. Faroni et al. [
10] proposed an adaptive hybrid sampling strategy that regulates the trade-off between local and global information. The performance, however, may exhibit significant variability contingent upon the problem’s geometry and the selected parameters. DG-RRT proposed by Huang et al. [
11] enhances efficiency by incorporating a dynamic gradient sampling strategy that concentrates guide points toward the goal region and employs a root-node iterative optimization method to refine paths. However, if the landmark points that a path must approach are involved, there guiding confusion will occur. The method proposed in this paper takes this problem into consideration. Although these sampling-based methods can produce more flexible paths compared to graph-based approaches, their performance can be highly variable depending on the sampling strategy and environmental complexity; additionally, the cost of the map is not taken into consideration. The proposed algorithm in this paper integrates the exploration of the global situation through sampling, and retains the cost information of the map by constructing the graph structure, using Dijkstra’s Algorithm to quickly generate the detection path.
Heuristic algorithms are widely used in path planning because of their high efficiency and flexibility. For example, the genetic algorithm optimizes the solution of a problem by simulating the process of natural selection, while particle swarm optimization finds the optimal solution by simulating the predation behavior of birds; other examples include simulated annealing, tabu search, and so on. To address the drawbacks of traditional ant colony optimization (ACO) algorithms, Miao et al. [
12] developed an enhanced algorithm (IAACO) for mobile robot path planning in an enclosed area. IAACO introduces angle guidance factors and obstacle exclusion factors to enhance safety in path planning, but it lacks a systematic evaluation regarding efficiency in diverse scenarios. The algorithm proposed in this paper has been verified in multiple scenarios. Cai et al. [
13] improves the ACO algorithm by integrating it with the firefly algorithm and heuristic functions, leading to enhanced performance in path planning for different environments. However, the performance is still heavily reliant on initial parameter selection and may not completely avoid local optima or oscillations in complex environments. While these methods demonstrate distinct advantages across various application scenarios, their lack of curvature constraints and other limitations make them challenging to implement directly in practical robot motion control systems.
In terms of smooth path planning, Kanayama and Hartman [
14] used two types of simple path sets to solve the path planning problem of symmetrical postures according to the defined smooth path cost, but there are problems such as discontinuous curvature. The algorithm combined with parameter curve smoothing scheme also has good performance. Most RRT-based extension algorithms can generate safe and smooth paths by combining parameter curve-based smoothing schemes. A path planning algorithm for a non-holonomic robot proposed by Fei et al. [
15] integrates cubic Bézier splines with Informed RRT. The algorithm ensures curvature continuity and kinematic constraints but increases computational complexity. Yang et al. [
16] proposed a Bezier curve-based algorithm to check the local smoooth path before each random tree expansion, ensuring smoothness and safety. Similar to this is Elbanhawi et al. [
17]’s C2 continuous algorithm based on a B-spline curve. However, these do not take into account factors such as the cost of the map and landmark points that the path must approach. The algorithm proposed in this paper considers these problems through strategies such as graph structure and point-by-point detection. Li et al. [
18] proposed a global path planning method based on the bidirectional alternating search strategy A* algorithm. This approach involves alternating searches for path nodes, utilizing Bezier curves to achieve path smoothing and introducing a path node filtering function to reduce redundant nodes. The algorithm effectively addresses the smooth path planning problem; however, it may still exhibit long computation times on large-scale maps, and its robustness in complex environments requires further verification. Liao et al. [
19] proposed the Stack-RRT* algorithm to generate the paths with varying continuity levels, which integrates with diverse parameterized curve smoothing schemes; Huang H.-C. [
20] used the parallel PSO algorithm to find a feasible route and then used cubic B-spline to smooth the route. These two methods rely heavily on the initial direction and the initial solution. The algorithm proposed in this paper effectively avoids this limitation. Bakdi et al. [
21] used a genetic algorithm to obtain an obstacle avoidance path, and then used piecewise cubic hermite interpolation polynomials to generate a smooth path without considering the maximum curvature. Song et al. [
22] combined Bezier curves with genetic algorithms, set the control points at the center of the grid, and the resulting smooth path was unable guarantee the curvature continuity at the connection points. Lin et al. [
23] solved the problem above by combining cubic Bezier curves with an adaptive delayed velocity particle swarm algorithm, which has equivalent curvature at the curve connection, thereby ensuring the smoothness and continuity of the entire path, but it does not consider that it is necessary for the robot to adjust avoiding deviating from the route. Saurabh and Ashwini [
24] present a path planning method using four-parameter logistic curves for continuous-curvature paths with obstacle avoidance, providing analytic solutions for generating smooth paths that avoid both rectangular and circular obstacles.
Existing approaches often overlook the actual situation, including critical factors such as the robot’s kinematic constraints and dynamic limitations. This omission may result in deviations from the intended path, introducing risks like control instability, mechanical wear, or unintended collisions during execution. The algorithm we proposed finds a low-cost path on a map with cost, and it has continuous curvature, avoids obstacles, passes through all given landmark points, and satisfies the minimum length of line segments between curves and the maximum curvature constraints of the curve.
4. Algorithm
We propose a two-stage algorithm. In the first stage, the graph structure is constructed by generating points on the map, and we use Dijkstra’s Algorithm to obtain the connection order of the landmark points; in the secondary stage, the Smooth Beacon Reconnection (SBR) algorithm proposed by us is used to find the key points of the path, and the low-cost path that meets the requirements is obtained after fine tuning.
The algorithm flow chart is shown in
Figure 4, and the algorithm pseudo-code Algorithm 1 is also shown. The input data include parameters, landmark points
(including the starting and ending points), the boundary, obstacles, and the map cost function
, among which the last four are the necessary elements of the map (
). In
Figure 4, the data flow along the dotted line, and the algorithm process is represented by the solid line. The parameters include the upper limit of the number of generating points
N, the control time
T, and the control distance
. By default,
; this is because according to the rule of taking points, there must be
. Here, we take the nearest smallest integer 4, and the incremental cost threshold
is 1. Since doubling the cost is considered significant, if this value is too large, it may cause the algorithm to be insensitive to high-cost regions. If it is too small, it will be overly sensitive, leading to the failure of the algorithm or even no solution. Some parameter selections are related to information, such as the map. The parameters selected in this paper can refer to
Section 5.2.
The first line initializes the map information point set
and puts all the landmark points into the set, setting the number of counts to 0; lines 2–16 take points from the map. If a random point
on the map satisfies that the distance to all points in the set
is greater than
, then the point is added to the set. The effect after generating the points is shown in
Figure 5, where the green points are the landmark points; the 17th line generates a graph structure
based on the Delaunay triangulation according to the point set. Up to this line of the algorithm, the time complexity is
, and the space complexity is
, in which n is the number of points. The effect is shown in
Figure 6. The weight of any side
in
is the line integral
of its map cost function
. The Delaunay triangulation is selected as the basic graph structure because it can more effectively represent the irregular characteristics of map cost than other structures such as grids.
Assuming the number of points of the graph is n, according to Euler’s Formula of the plane
where
and
represent the number of edges and faces, respectively. Each triangle has three edges, and each edge is shared at most by two triangles, so
. The simultaneous solution gives the following:
When the case of the graph structure boundary is not considered, that is, each edge is shared by two triangles, it follows that
That is, the number of edges increases linearly with the number of points:
Similarly, in the grid graph, the following is the case:
and then
In the case of the same number of points, the Delaunay triangle-based graph has more edges and can cover more information.
The next step needs to determine the connection order of the landmark points, which corresponds to line 18 of the pseudo-code. As shown in
Figure 7, the cost between two landmark points is determined by the shortest distance determined by Dijkstra’s Algorithm on the graph
. As shown in
Figure 8, a Hamiltonian circuit is constructed by adding a virtual node, where the distance from the virtual point to the starting point and ending point is 0, and the distance from other nodes is infinite. This Hamiltonian circuit can determine the connection order of each landmark point. The red point in the figure is the virtual point, while the green points represent the starting and ending points, and the blue points serve as landmark points, thus completing the first step of the algorithm. Up to this line, Algorithm 1 resolves the issue of connection order among landmark points.
The second step of the algorithm sees the 19th and 20th lines of Algorithm 1. The connection order of the landmark points obtained in the first stage are processed one by one. The pseudo-code of the algorithm in the 19th line is shown as Algorithm 2 Smooth Beacon Reconnection
, where the first line initializes the set of information nodes and key points. From the second line to the seventh line, new information nodes are obtained as part of the key points, and the fourth line indicates that the landmark point is transitioned in the form of a line segment according to the trend of the landmark points. The use of a line segment rather than a curve for the transition is because a line segment is better suited to real-world needs, such as picking up goods or refueling.
Algorithm 1 Smooth path search based on two stages |
Input: - 1:
Initialization: - 2:
while
do - 3:
- 4:
if then - 5:
- 6:
- 7:
else - 8:
for do - 9:
if then - 10:
break - 11:
end if - 12:
- 13:
- 14:
end for - 15:
end if - 16:
end while - 17:
- 18:
- 19:
- 20:
Output: |
Figure 9 shows the generation of the trend according to the connection order, the dotted line represents the connection order, and the solid line represents the direction trend generated by the connection order. The blue dot represents the landmark point being processed, and the green dots represent the two landmark points before and after it.
Figure 10 shows the transition of the landmark point with line segments; that is, two key points are generated in the trend direction, where the direction of the trend line is controlled by the position of obstacles and the length of the line segment. The blue dot is the processed landmark point, and the green dots represent the two landmark points before and after it. When the original direction leads to obstacles in the way, the direction will be adjusted. And the parameter of the length of the line segment is determined by the minimum line segment length and the maximum curvature in the constraint.
The specific practices are as follows: If the order is determined, the connection order of three landmark points is
,
, and
. The middle point
is transitioned by passing through a line segment. The direction of the line segment is
. Based on the assumption that all landmark points complete the transition through the line segment, two information nodes are generated by one landmark point in the trend direction, where the direction of the trend line is controlled by the position of the obstacle and the length of the line segment. For example, the direction will be adjusted when the original direction causes obstacles in the path; the adjustment method takes the landmark point as the center and swings the trend line until the transition line segment does not pass through the obstacles, generally within
debugging. The line length parameter is determined by the minimum line length and maximum curvature in the constraint, and is generally set to
, which ensures that the constraints are satisfied after smoothing. This is because after removing the length of the
of the constraint here, the maximum distance from each key point to the starting point of clothoid after being inserted into the curve is
. Through
Section 3.3, we know that this value is
. Combined with the content from
Section 3.1, we have the following:
Therefore, we should ensure that
It is generally believed that an angle greater than
at each key point is in line with practical significance. A larger angle makes the path more gentle. In
Section 5.2, we set the maximum curvature to 0.2 and the minimum value of the minimum line segment length between the curves to 2. Therefore, Formula (
26) has a solution. More generally, the minimum value of the minimum line segment length between curves
is set to
. The end of this step adds the information nodes to
and the set of information nodes is
The algorithm starts from line 8 to find key points in groups of two information nodes. At this time, each group of end points is connected by line segments in line 4 of the algorithm. Lines 10 and 18 indicate that the information nodes from the previous step are added to key points . The shortest path Localpath on the map is generated by Dijkstra’s Algorithm. Then, in lines 12 to 17, the points are methodically checked from the start to the end in the group. The reason why each node is set as the beacon first is that the point detected at this time may not necessarily be smoothed as a key point. Line 13 indicates that when the calculation is made in the form of a line segment, if the cost increases significantly, the increment exceeds the set threshold of the original cost times; then, the preceding node of the check node is set as a beacon node and a new starting point at the same time, and the checking of each point is continued until the end. If the value of is 0, then every point on Localpath becomes a beacon node.
The specific practices are as follows: If the starting point is S and the ending point is E, the landmark points are , , and in the connection order. After the transition of the previous step, the landmark points are connected in line segments at this time. The current node order is as follows: S, , , , , , , E. Among them, , , , , , are information nodes. The number of all information nodes is . The 2 indicates that there is a starting point and ending point, and indicates the number of landmark points. Since each landmark point generates two information nodes, the total number must be an even number. Now the grouping is as follows: , , , ; the beacon point can be searched for by line check calculation.
Figure 11 shows the process of finding key points. The gray area represents the high-cost area or prohibited area, the red dotted line represents the check node with increased cost after inspection, and the red solid line represents the result after inspection. Line 19 of Algorithm 2 calculates whether the current key point meets the smoothing generation conditions and whether it passes through the forbidden area after generation. If not, adjustments will be made, such as moving backward along the direction of the obstacle to generate the key point, as shown in
Figure 12. It can be seen that the focus of the second stage is to find a beacon to turn the key point. After the curve insertion is completed, the generated path satisfies all the constraint conditions.
Algorithm 2 SBR |
Input: - 1:
Initialization: - 2:
- 3:
for
do - 4:
- 5:
- 6:
end for - 7:
- 8:
for to do - 9:
- 10:
- 11:
- 12:
for to do - 13:
if then - 14:
- 15:
- 16:
end if - 17:
end for - 18:
- 19:
- 20:
end for Output: |
Through the SBR algorithm, we can obtain the key point set of the model. Line 20 of Algorithm 1 shows the generation of a smooth path based on the key point set. The steps of smoothing are as follows: according to the key point set and its generating order, these key points are connected by line segments, and then the arc and clothoid are inserted at the position of each turning point (except the key points of the starting point and the ending point). The size of the insertion radius of each part is determined by the constraints and map information. Here, we obtain the optimal radius with the particle swarm algorithm (PSO). The goal is to minimize the cost under the condition of meeting the constraints.
In the PSO algorithm, every particle corresponds to a feasible solution in the optimization domain, and its position and velocity indicate the value and search direction of the solution, respectively. The formula for updating the particle’s position and velocity is as follows:
where
and
represent the velocity and position of the
i th particle in the
j dimension at the t iteration,
w is inertia weight,
and
is constant,
and
are random numbers in the interval [0, 1],
is the historical optimal position of particle
i, and
is the historical optimal position of the group. The PSO algorithm offers notable strengths, including rapid convergence rates and robust global exploration capabilities.
Figure 13 illustrates the position update mechanism in PSO, where the red five-pointed star denotes the global optimum, the blue dots
and
g represent the individual particle’s historical optimum and the collective optimum, respectively, while the green dots indicate the particle’s current position and its position for the next iteration. Obviously, under the uniform cost condition, the minimum-cost path is the shortest route, and the insertion radius should be the minimum radius.
The optimization problem (
12) involves a large search space due to the joint optimization of multiple constraints. To address this complexity, our two-stage algorithm decomposes the problem into a global coarse search (landmark ordering via Dijkstra) and local refinement (key point adjustment via SBR). This hierarchical approach significantly reduces the search space by decoupling decisions from geometric constraints. Furthermore, the proposed algorithm adopts Dijkstra’s Algorithm to determine the connection sequence of landmark points and conduct point-by-point detection. Dijkstra’s Algorithm itself has deterministic convergence characteristics and can find the shortest path in the graph structure within a shorter time. Although the generation of the point set is based on random sampling, the graph structure constructed through Delaunay triangulation ensures the completeness of spatial coverage, thereby ensuring that a superior solution can be obtained through fewer sampling points within a limited time, and it can also be reflected in the experimental
Section 5.2. The time complexity of the SBR Algorithm 2 is
, and the time complexity of the entire two-stage Algorithm 1 is
.