Development and Evaluation of Multi-Robot Motion Planning Graph Algorithm

1. Introduction

Motion planning is commonly encountered in environments where several robots operate simultaneously and with multiple obstacles. Motion planning collision-free paths is an important field of robotics, enabling coordinated and efficient operations in various real-world applications [1]. It is also widely used in industrial automation and search and rescue operations such as exploration, object transport, and target tracking [2,3]. A key challenge in motion planning problems is determining an efficient path from an initial location of each robot to the required destination while maintaining connectivity by balancing path optimality and computational efficiency [3,4]. Motion planning is a requirement for ensuring safe and efficient movement of the robots to complete their allotted tasks [5]. Motion planning considers the obstacles in the operational environment and the movements of robots in the environment. Several approaches exist for robots’ navigation, however path planning for multiple robots introduces several challenges, e.g., avoidance of collision and maintaining communication [6,7]. The existing methods, such as potential fields, cell decomposition, and roadmap techniques often do not address these challenges simultaneously. The choice of motion planning depends on the environment and the capabilities of robots. Graph models are more appropriate for robot path and motion planning problems as they provide an intuitive, computationally effective approach to map and navigate the environment. The environment is a configuration space where robots and obstacles are located [8,9].

Graph models are foundational in multi-robot motion planning where the vertices represent specific locations or points of interest in the operational environment and the edges represent the paths or connections between these locations. Thes graph structure allows the planners to use algorithms to determine the shortest or most efficient route between feasible points for the robots to travel [8,9]. Different roadmaps were suggested to achieve this operation, e.g., visibility graphs (VGs) and Voronoi diagrams (VD) [10]. A more popular method used in motion planning problems diagram comprises of Voronoi cells, each associated with a specific site. The edges are equidistant from two or more sites, forming cell boundaries. The cells are entirely convex polygons in 2D and partition space, with no gaps. Voronoi edges are not necessarily straight paths but represent boundaries of the regions based on proximity. Also, VD paths are as far away as possible from the obstacles [10,11,12,13]. Although VD generates long paths that are far from the obstacles (this makes it relatively safe, i.e., collision avoidance due to an increased distance between obstacles and robots, the paths are not optimal [10,11,12]. VG is also a popular method for robot path planning in environments with obstacles. It comprises of vertices and edges representing direct lines of sight between the points. The nodes typically include the obstacles’ vertices, start and end points of the robots’ paths. The edges are straight lines connecting visible nodes, with associated weights often representing the Euclidean distances. An advantage of using a VG for motion planning is its well-understood and straightforward method that produces optimal paths in a two or three-dimensional workspace [9]. It is also computationally effective and guarantees an optimal path when one exist [10,11]. In contrast to the Voronoi diagram, VG guarantees an optimal path; therefore, this study focused on the VG in 2D environments [10,11,12]. This work proposes and evaluates a hybrid approach to solving the multi-robot motion planning problem. It combines VG for path planning, the Dijkstra’s algorithm for optimal path finding, and algebraic connectivity to address path optimisation and maintaining robust communication. The approach is highly suitable for static 2D environments, as the layout is predefined, and the robots need to coordinate their navigation to avoid collisions and stay connected. The traditional path-planning methods often focus on optimising path lengths but neglect the significance of maintaining communication that is critical for cooperative missions.

The Dijkstra’s and A* algorithms were widely used to find the shortest path, but they differ in how they approach the problem and their efficiency in various scenarios [14,15]. In a weighted graph, the A* algorithm aims to find the shortest path between a starting node and a target node with heuristics, especially in environments where a goal is defined. The choice of the heuristic function is crucial. It must be admissible, meaning it never overestimates the actual cost to reach the goal, ensuring that A* finds an optimal path. However, its data storage requirement can be high, as it stores details of all generated nodes, which can be a limitation for large-scale problems. The heuristic method uses assumptions to minimise the complexity of pathfinding. This is a limitation as it requires multiple variables and coefficients which the algorithm designer must select. Also, a well-defined manner for determining these variables has not been previously reported. As a result, the heuristic methods do not provide general solutions. In other cases, the variables of a heuristic algorithm might need modification [16]. The A* search algorithm was not considered in this study because when it is combined with the VG method, the resultant path might not be optimal. It is challenging to compute the heuristic of A*, where the heuristic value is typically a computation of what the straight-line distance to the target would be, if there were no obstacles. Therefore, there is not a method to measure the cost of the straight lines that connects vertices to the goals in an environment where the lines pass through the obstacles. Also, if the heuristic cost is not acceptable, i.e., higher than the actual cost, the identified path may not be optimal regarding the path length [10,11,13]. Therefore, the VG and the Dijkstra’s algorithm are chosen for path planning in this study. Accordingly, a multi-robot motion planning problem becomes the problem of finding the optimal (i.e., the safest and shortest) paths. Furthermore, the VG method can help the robots in the system to move to the desired goal (g) location while avoiding collisions [10]. To integrate algebraic connectivity into this method for multi-robot motion planning, cooperation among robots is optimised by considering the graph’s connectivity that represents their paths. The algebraic connectivity is the second-smallest eigenvalue (λ₂) of the Laplacian matrix of a graph that reflects the extent of a graph’s connectivity. A large value for λ₂ implies a more robust and a well-connected graph that benefits coordination in multi-robot systems [9].

In this study, the operating environment was a 2D space with polygonal obstacles accommodating multiple robots, each with a start location and a goal position. The aim was to find collision-free paths for the robots as they moved to their respective goals while maintaining a high level of connectivity. This goal was achieved by considering the algebraic connectivity of each robot’s communication graph. The paths in the vector environment model can be represented by the VG [5,8] which has been effective in many applications because of its simplicity, visualisation, and completeness [8]. VG used for multi-robot path motion planning is described as an undirected weighted graph $G\left(V,E,W_E\right)$,where V is the set of vertices representing the robots configurations, the starting and the endpoints of the robot’s movement, $E\subset V\times V,\mathrm{w}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{e}V\times V=\{\left(v_i,v_j\right),v_i,v_j\in V\}$ is a set of edges representing the paths between the vertices. In the expression $E\subset V\times V$, the symbol × denotes the Cartesian product of the set $V$ with itself. The Cartesian product V×V is defined as the set of all ordered pairs ($v_i,v_j$) where both $v_i$ and $v_j$are elements of V. Formally, this is expressed as: $V\times V=\{\left(v_i,v_j\right),v_i,v_j\in V$. In graph theory, this indicates that E, the set of edges, is a subset of all possible ordered pairs of vertices from V. Each edge ($v_i,v_j$) in E represents a connection from the vertex $v_i$ to vertex $v_j$. This framework is fundamental in defining the structure of directed graphs, where the direction of the edge is significant. $W_E$is a function that assigns the weights (i.e., the path length) to each edge in E. Depending on the context, these weights can represent various attributes, such as distances. The edges denote the physical distance between two points, essential in applications like GPS navigation and logistics. The weights may represent the cost or resource requirements associated with traversing an edge, aiding in optimizing routes to minimize cost. Capacities indicate the maximum flow between the nodes, which is crucial in network design and traffic management. This notation is valuable in problems involving weighted graphs, like finding the shortest path [6,8,17,18]. Edges join all pairs of mutually visible nodes and the edges of the obstacles [18]. Edges exist between two vertices when there is a direct line of sight between them, meaning that the line connecting the vertices does not intersect any obstacle. VG provides a representation of the environment that helps identify robot obstacle-free paths [19]. The weights of an edge represent the Euclidean distances between vertices [20]. Hence, based on the problem’s requirements, it is essential that the VG covers connectivity effectively to avoid a collision and calculates the best path (i.e., the shortest and safest) for the robots [21,22]. Connectivity is critical for a multi-robot team to coordinate and execute complex missions efficiently [9,23]. Algebraic connectivity ensures that the multi-robot system remains well-connected during motions, facilitating communication and coordination. The Dijkstra’s algorithm finds each robot’s shortest path while respecting the connectivity constraints. This optimisation balances between minimising the path lengths with maintaining robust communication among robots [9,23].

This study's contributions include a novel integration of the VG and algebraic connectivity, a communication-path optimisation strategy using Dijkstra’s algorithm, and an evaluation of the proposed methods in static 2D environments. The contributions also include a new path adjustment method based on algebraic connectivity for maintaining strong communication while optimising path lengths (i.e., an optimisation framework that balances path length and network robustness), which addresses the limitations of previous approaches in connectivity maintenance and path efficiency. Combining VG with algebraic connectivity enhances multi-robot systems by ensuring robust communication and an efficient path planning throughout the mission. Our method simultaneously optimised path length and communication robustness. This made it more promising where communication between robots is critical, especially in cooperative tasks. Connectivity indicates a more resilient network capable of withstanding individual robot failures without losing overall connectivity. Therefore, enhancing algebraic connectivity strengthens the communication network, ensuring the robots remain connected during operations. In the following sections, the related theory is explained, the study’s methodology is described, and the results are discussed.

2. Related Theory

In this section the theoretical concepts related to the study are explained.

2.1. Overview of Multirobot Path Planning Algorithms

Considering a multi-robot environment which has a limited finite communication range (R) and is modelled as an undirected weighted graph $G=\left(V,E,W_E\right),$ the following are defined:

• $V=\{1,..,n\}$is the set of vertices representing the n robots,
• $E\subseteq \{V\times V\}$ is the set of edges representing paths between vertices, where $e_{ij}$,$i\ne j$, exists between vertices, if robot n interacts with robot m; this means two robots can communicate only if they are within the communication distance of each other, also the presence of the edge $e_{ij}$refers to the presence of the edge$e_{ji}$. Therefore $e_{ij}$=$e_{ji}$, signifies that the edge is mutual and directionless. This characteristic is fundamental to undirected graphs, where edges do not have a specific direction.
• $W_E$ is function that assigns the weight (length path) to each edge in E. $W_E=\left\{w_{ij}\right|(i,j)\in V\times V\}$ is a set of weights so that $w_{ij}=0,\mathrm{i}\mathrm{f}(i,j)\notin E$ and $w_{ij}>0$ otherwise.

If we consider a team of n robots, the set of neighbors of the ith robot can be defined as $n_i=\left\{j\in V,j\ne i\right|e_{i,j}\in E\}$, all robots that can communicate with it. Hence, each robot is assumed to be able to interchange data with its neighbors [9,23,24]. A method to represent such an undirected weighted graph is using the Laplacian graph and its algebraic connectivity as an indicator of the system’s connectivity. The algebraic connectivity is defined as the second smallest eigenvalue ${(\lambda }_2\left(L\right)$) of the graph Laplacian. Let the graph Laplacian $L\in R^{n\times n}$ be the weighted matrix which combines the adjacency (A) and the degree matrix (D). Here$w_{ij}\in R^{n\times n}$ is the weight function, which can be seen as a function of the distance between robots i and j. ${\lambda }_2$is called the algebraic connectivity value of the system. The value of the algebraic connectivity differs from zero (${\lambda }_2$= 0) if the graph has disconnected components, i.e., no paths among vertices or two disconnected components [25,26]. If ${\lambda }_2$ is very small, it refers to the graph being nearly disconnected. Non-zero connectivity refers to a path among every pair of vertices (robots in the system) in the graph. A higher algebraic connectivity signifies a more robust and well-connected graph with many edges, i.e., the value of ${\lambda }_2$ ranges between 0 and the number of vertices (N). In addition, connectivity refers to the number of vertices in the graph, if the graph is completely connected. Thus the maximum value of${\lambda }_2=N$, and it is obtained when the entries $(i,j)$ of the adjacency matrix are all equal to 1, that means all possible edges are present in it [9,23,24].

2.2. Algebraic Connectivity for Communication of Multi-Robot Systems

The second smallest eigenvalue (${\lambda }_2)$is indicated as a constraint to maintain communication during the motion. It ensures the robots remain well-connected for communication or coordination during their tasks. This is critical in scenarios where the robots need to share information or collaborate to perform tasks. The term ${\lambda }_2$ is a function of the whole system’s state. It is an important parameter that affects the performance and robust properties of dynamical systems working over an information network [24]. Algebraic connectivity maintains connectivity and enables them to execute tasks while maintaining connectivity within the system. Connectivity is managed by strategically adding edges that optimise the network's structure to maintain robust communication within the system. This involves measuring the second smallest eigenvalue of the Laplacian matrix, known as the algebraic connectivity, and iteratively adjusting path calculations to ensure ${\lambda }_2$remains high. A higher algebraic connectivity signifies a more resilient network capable of withstanding individual node failures without losing overall connectivity. By focusing on this metric, the system enhances communication robustness while minimising path lengths [24,25,26]. Hence, this enables the robots to obtain complete information about the surroundings of the workspace environment to avoid collision and to find the best safe paths. The weights of the edges control the motion time of robots, where edges’ weights are functions of the inter-robot distances. Consequently, these weights can directly influence the time taken for a robot to move along a particular path. In robotics, motion time refers to the time for a robot to traverse from one location to another within the network. For example, edge weights are determined by inter-robot distances; a greater distance (and thus a higher edge weight) would typically correspond to a longer motion time for robots. This relationship is crucial in optimising robots’ trajectories to ensure efficient movement and coordination within the system, and it is essential for effective motion planning and coordination in multi-robot systems [9,23].

In a workspace environment, we have assumed that the obstacles were convex, static and that the distance between any two obstacles was greater than the size of robots. We considered two types of collisions: (i) collision between an obstacle and a robot and (ii) inter-robot collisions (i.e., collision between two robots). Each robot could determine the presence of an obstacle and measure its relative location and the distance from its boundary within the communication range. Therefore, the aim was to solve the problem of a team of multi-robots, which began from the first configuration where the team was connected (${\lambda }_2$ > 0), maintaining connectivity whilst being controlled to achieve a desirable objective to avoid collision until reaching the target configuration. A collision avoidance mechanism was executed that prevented robots from colliding with each other. Their communication was defined based on the weights of the edges (which determined the quality of the communication links between the robots), and when ${\lambda }_2$ was non-zero, whilst every robot tracked its paths to reach its goal location [9,23,24]. In addition, during the path planning, the weights ($w_i$) of the vertices changed and became equal to the moments at which the robot ($R$) passed through these vertices [8]. Therefore,

$$w_j=\left\{\begin{array}{c}{w}_i+w_{ij},if(w_i+w_{ij})<w_j\\ w_j,if(w_i+w_{ij})\ge w_j\end{array}\right.\left(1\right)$$

(1)

where $w_i$ is the vertex weight, and $w_{ij}=e_{ij}$is the edge weight (i.e., the distance between the vertex $v_i$and vertex $v_j$).

2.3. Collision Avoidance

To provide collision avoidance, the weights of the edges can be modified during path planning, either by path correction, where a robot is not allowed to move on the edge that is occupied by another robot, or through controlling the robot’s motion time on some edges by controlling the distances between the vertices to free up the paths for other robots, the paths of which are planned earlier [8]. This means the increased time of the robots to traverse the graph edge from vertex $v_j$. So, we have two principal conditions that need consideration for path correction and control robot motion time to avoid a collision. First, two robots cannot cross paths simultaneously on the same vertex of a graph. Thus, if this happens, to prevent collisions, let $T_{R_n}$be the arrival time (i.e., the time when robot passes through the vertex $v_i$, and $R_n$be nth robots, (n=1,2,…,p and p represents the number of robots). $T_{R_n}$ is expressed as

$T_{R_n}=w_i+w_{ij}\left(2\right)$

In the given context, $T_{R_n}$represents the arrival time of robot$R_n$ at vertex $v_i$. $w_i$denotes the time at which robot $R_n$departs from vertex $v_i{w}_{ij}$ represents the travel time required for robot$R_n$to move from vertex $v_i$to vertex $v_j$. Therefore, the equation suggests that the arrival time $T_{R_n}$ at vertex $v_j$is the sum of the departure time from vertex $v_i$ and the travel time between vertices $v_i$and $v_j.$This formulation is commonly used in multi-robot path planning and scheduling to ensure coordinated movements and to avoid collision.

We will assume that $ϵ>0$ is a minimum value of safe distance to ensure collision-free motions. Then$w_{ij}=w_{ij}+ϵ$, must provide a safe passage for the robots when crossing the crossroads through increased weight edge (distance) on the graph from the vertex ($v_i)$ to vertex ${(v}_j)$ to increase the motion time of the robot on a graph edge by $ϵ$ time units that correspond to its motion time change. By other means, ϵ is a small increment; the unit of which is typically meters, or the relevant unit of distance measurement used within the system. By incorporating ϵ into the edge weights of the graph, the weights are iteratively adjusted to avoid collision between the robots by incrementing ϵ to obtain optimal weights that improve its performance on the given task. This adjustment effectively increases the perceived distance between vertices $v_i$ and $v_j$, discouraging robots from occupying the same intersection simultaneously and thereby reducing the risk of collisions. Therefore $ϵ$ is a safety value from which two robots will not collide, the weight $\left(w_j\right)$of vertex $v_j$ is calculated according to Equation 1. Second, it is not permissible for any two robots to move together on the same edge in opposite directions. Therefore, if any two robots are moving in opposite directions on the graph edge (straight paths) at the same time, then

$(w_i>T_{R_{ni}})^\left[\right(w_i+w_{ij})>T_{R_{nij}}],$ then $T_{R_m}>T_{R_n}\left(3\right)$

Given mth robot ($R_m$) and nth robot ($R_n$), $(w_i>T_{R_{ni}})^\left[\right(w_i+w_{ij})>T_{R_{nij}}]$ part in Equation 3 implies that two conditions need to be satisfied simultaneously (the symbol ^ denotes the “AND" operation). These conditions compare weights $w_i,w_{ij}$, and the arrival times of $T_{R_{ni}}\mathrm{a}\mathrm{n}\mathrm{d}{T}_{R_{nij}}$. The $T_{R_m}$>$T_{R_n}$ part in Equation 3 implies that the time for $R_m$, i.e., $T_{R_m}$ must be greater than the time for $R_n$, i.e., $T_{R_n}$, because of the previous conditions. No collision occurs as $R_n$ passes through the edge before $R_m$, whose path is being planned and drives onto the edge. Hence, in this case, the edge weight does not require changing. Then, the vertex weight $w_j$is calculated as Equation 1. $T_{R_n}$ depends on the distance $(d_{ij}$ = $w_{ij})$between the edges of the graph. If $T_{R_m}>T_{R_n},$this means the distance travelled by $R_n$ is less than the distance travelled by $R_m$, hence the arrival time of $R_n$is greater than the arrival time of $R_m$[8]. On the other hand, if

$$T_{R_m}<T_{R_n}^\left[T_{R_m}\le {\displaystyle \frac{\begin{array}{cc}{w}_i\left(T_{R_n}-T_{R_m}\right)-& w_i{T}_{R_m}\times w_{ij}\end{array}}{T_{R_n}-T_{R_m}-w_{ij}}}\le T_{R_n}\right]\left(4\right)$$

(4)

then, a collision occurs because$R_n$, whose path is being planned follows $R_m$ on the edge and collides with it due to the distance travelled by it being too short. To avoid a collision, it is essential to modify the edge weight of the current robot (i.e., reduce the movement of the robot, whose path is being calculated). This means increasing its arrival time by increasing distance in this edge as

$w_{ij}={\displaystyle \frac{\left(w_i-T_{R_n}-ϵ\right)(T_{R_n}-T_{R_m})}{\begin{array}{ccc}{T}_{R_n}-& T_{R_m}-& ϵ\end{array}}}$ $\left(5\right)$

Then, the vertex weight $w_j$ is defined as Equation 1. In addition, if

$(w_i<T_{R_{ni}})^\left[\right(w_i+w_{ij})<T_{R_{nij}}],$then$T_{R_n}>T_{R_m}$ (6)

This occurs when two robots move in opposite directions, and $R_m$whose path is being planned crosses through the edge before $R_n$, no collision will occur; thus, the weight of edge does not need to change. The weight of the next vertex $w_j$ is calculated as Equation 1. In contrast, if

$T_{R_n}<T_{R_m}$^$\left[T_{R_n}\le {\displaystyle \frac{w_i\left(T_{R_m}-T_{R_n}\right)-T_{R_n}\times w_{ij}}{\begin{array}{ccc}{T}_{R_m}-& T_{R_n}-& w_{ij}\end{array}}}\le T_{R_m}\right]$ (7)

A collision is possible when the robot $R_n$ follows the robot$R_m$, which its path is being planned, and collides with it on the edge [8]. To avoid a collision, it is essential to modify the edge weight of the current robot (i.e., changing the arrival time through increasing distance) according to Equation 5, and then the vertex weight $\left(w_j\right)$is defined as Equation 1. Also, if

$(w_i<T_{{Rn}_i})^\left[\right(w_i+w_{ij})>T_{{Rni}_j}],(i=1,2,\dots ,n),$ then $T_{R_n}<T_{R_m}$ (8)

Then the collision is possible when $R_n$ follows and collides with $R_m$, which its path is being planned before the crossroads [8]. To avoid a collision, the arrival time of the current robot must be increased. So, the edge weight must be changed based on Equation 5, and then the vertex weight$(w_{j)}$ is calculated as Equation 1.

3. Materials and Methods

In this section the procedures followed to obtain the results are described.

3.1. Operation of Mult-Robot Path Planning Algorithm (MRPPA)

To address the motion planning problem for a multi-robot system and to find a collision-free optimal path, the algorithm based on the VG method is proposed. The algorithm consists of the main tasks (i)-(vi):

• Establish a free workspace map.
• The algorithm defines each robot’s starting position ($s_i$) and goal positions ($g_i$) and the number and locations of obstacles.
• All obstacles in the map are modelled as polygons to facilitate efficient and accurate pathfinding. A polygon also allows creation of visibility graphs where the vertices represent the obstacle corners, and the edges denote direct lines of sight between them. This framework is essential for determining the shortest collision-free paths. Polygonal obstacle modelling aids in expanding the obstacles appropriately to account for the robot's size. This process ensures that path planning algorithms consider the robot's physical footprint, preventing collisions. Also, robotic systems can effectively navigate complex environments, ensuring accurate and efficient movement, while avoiding collisions. The algorithm analyses the position of each obstacle’s vertices. The robots’ starts and goals positions are known relative to the obstacles in the surrounding environment. Each robot is considered a dynamic obstacle.
• Using the constructed free space and VG algorithm, the robots can navigate without colliding with the obstacles.
• The workspace environment is divided into two disconnected components of undirected weighted graphs. Then, the best edges are chosen to add between these two graph components to find the paths for each robot, based on the measured values of algebraic connectivity of graph Laplacian, which controls the inter-robot connectivity when it is unequal to zero.
• When planning a path for a robot, its vertex weight is changed just as in the single-robot path planning algorithm. The weights of the vertices of the graph are initialised with the maximum possible value, i.e., infinity (∞), whilst the start time value initialises the start vertex (${s_i=w}_0$ = $t_0$). According to the known edge weights, the Dijkstra’s algorithm is applied to find the shortest path based on the cost corresponding to each edge (distance between vertices), where the shortest path is the path with the minimum length. Therefore, it is required to find a vertex sequence (series waypoints), which denotes the shortest path from the starting point to the goal point. If the Dijkstra’s algorithm finds the shortest paths, the robot’s path can be changed based on the distance, corresponding to the environment model correction. The MRPPA algorithm is described as:
  Inputs: Start positions ($S_i$), goal positions ($g_i$), polygonal obstacles ($O_i$).
  Outputs: Visibility graph (VG), Optimal paths from start ${(S}_i$) to goal ($g_i$).

• Establish a free workspace map.
• Determine each robot’s start $s_i$and goal $g_i$positions and obstacles’ vertices numbers and locations.
• Divide the workspace environment into two disconnected components of undirected weighted graphs $\left\{G_1,G_2\right\}$.
• Select the best edges ($w_{ij}$, where i and j represents the edge between two vertices) to add between these two components of the graph $\left\{G_1,G_2\right\}$ based on the measured value of algebraic connectivity of graph Laplacian (${\lambda }_2$).
• Create the visibility graph (VG).
• Find a vertex sequence (series waypoints) from the start ($s_i$) to goal ($g_i$) by using Dijkstra’s algorithm, which denotes the shortest paths.
• End: paths is calculated $\widehat{W}=\left\{w_i=w_0,.....,w_n,i=1,\dots ..,n\right\},$ where $w_0$start point and $w_n$ = goal point.

The operations of MPRR algorithm are also illustrated in Figure 1.

The key objective of the MRPP algorithm is to find optimal paths for all robots by minimising the path length. It maintains λ₂ of the communication graph at a high level to ensure the multi-robot system remains connected during the motion and provides collision avoidance.

3.2. Procedure to Implement MRPPA

The MRPPA was implemented by following the steps:

• Create VG for the environment, including all the start and goal positions of the robots. Each robot can be represented as a vertex, and edges existing between the robots. The edges (connections) between these vertices refer to the corresponding robots, are within a certain communication range and can directly exchange information.
• Evaluate connectivity by calculating ${\lambda }_2$ and define the communication or interaction graph between the robots. The Laplacian matrix L of this graph is constructed, and its eigenvalues are determined (${\lambda }_2$). Higher algebraic connectivity implies that the robots are well-connected, meaning the communication graph is robust to disconnection for coordinated motion.
• Carry out an initial path planning by using the Dijkstra’s algorithm to find each robot’s shortest path from start to finish.

3.3. Description of the Optimisation Process

During a motion planning process, the algorithm selects paths for the robots that minimise their travel distance and ensures that each robot network’s algebraic connectivity is improved and maintained [25]. The optimisation process involves calculating the paths and connectivity at each step as outlined by the steps below.

• If ${\lambda }_2$is the small, indicating weaker network connectivity, the paths can be adjusted to improve connectivity. Robots’ paths can be altered to keep them within the communication range of others. This may involve adding edges to maximise or maintain a high level of algebraic connectivity, thereby strengthening the network's resilience to disconnections. The objective of adding edges is to increase robot proximity, increase ${\lambda }_2$, improve connectivity and to ensure the communication graph remains connected.
• Run the Dijkstra’s algorithm on the visibility graph for each robot to find the shortest initial paths.
• Repeat the above operations until optimal path lengths are obtained for all robots to reach their targets while maintaining communication.

4. Results

The key aim of the optimisation is minimising the path length (the total distance travelled by the robots) while maintaining a minimum level of connectivity in the communication graph. To illustrate how the algorithm operated, a scenario comprising six obstacles was considered as shown in Figure 2. The robots are R₁-R₃ and associated goals are g₁-g₃.

The workspace scenario depicted in Figure 2 is represented as an undirected weighted graph in Figure 3. In this figure, the vertices correspond to specific locations or points within the workspace, and the edges represent the possible paths connecting these points. The weights assigned to each edge indicate the cost or distance associated with traversing that path, facilitating the analysis and optimization of movements within the workspace.

In this scenario, there are three robots and three goals. The workspace is divided into two disconnected components of an undirected weighted graph using VG, such as in Figure 4.

The graph $G=\left(V_i,E_j\right)$ in Figure 3 consists of vertices $V=\left\{v_1,..,v_{30}\right\}$ marked from $S_i$=$\left({v_1=R}_1,{v_{28}=R}_2,v_3=R_3\right)$to$\left({g_1=v_{30},g_2=v}_2,g_3=v_{29}\right)$ and E = {$e_1,\dots ,e_{69}$}. There are six polygonal obstacles ($O_i$, $1\le i\le 6$). Each robot has an initial position ($s_i$) and the goal position$\left(g_i\right).$Here, there are three goals for the three robots. The second smallest eigenvalue of the graph in Figure 2 has zero value, i.e., (${\lambda }_2=0),$which means the graph is disconnected. The robots ($R_1=v_1,R_2=v_{28}$, $R_3=v_3)$ exist in the first component that contains vertices:$\left\{v_1,v_3,v_7,v_{9,},v_{11},{v_{13},v_{15,},v_{17},v_{19},v}_{28},v_{29}\right\}$, where vertex$(v_{29}=g_{3,})$ is a goal for $R_3$. Subsequently, $R_3$ can find a way to reach its target $R_3\to v_4\to V_7\to v_{29}$, but $R_1$and $R_2$ do not have paths to reach their targets. The second component contains vertices:$\left\{v_2,v_4,{v_5,v_{6,},v_8,v_{10},v_{12,},v_{14},v_{16,},v_{18},v_{20,},v_{21},v_{22,},v_{23},v}_{24,},v_{25},v_{26,},v_{27},v_{30}\right\},$vertices $(v_{30}=g_1,v_2=g_2)$ are goals for $R_1$ and $R_2$ respectively. When an edge was added between the vertices $v_6$ and$v_{14},{\lambda }_2$ increased to 0.087, and this enabled R₁=v₁, to find a path to reach its target ${(g}_1=v_{30}$ ). Whereas if two edges $\left(v_8,v_{10}\right)\mathrm{w}\mathrm{e}\mathrm{r}\mathrm{e}$ added and$(v_8,v_{17}$), ${\lambda }_2$ increased to 0.181 which allowed $R_3$ ( $R_{3=}{v}_3)$ to find the most suitable path to reach its target${(v}_{29}=g_3).$ Furthermore, when the three edges were together {$\left(v_2,v_{10}\right),\left(v_8,v_{20}\right),(v_{2o},v_{28})$}$,{\lambda }_2$ increased to 0.347, and R₂ ${(R}_2=v_{28})$ found a path to reach its goal ${(g}_2=v_2$). When all possible paths were added between the vertices of the graph, the second smallest eigenvalue increased and a robust connectivity was created in the graph, where${\lambda }_2=$ 6.380. The safe shortest paths are found using Dijkstra’s algorithm, as shown in Figure 5. The shortest paths for three robots using Dijkstra’s algorithm is shown in Figure 6.

The MRPP algorithm planed the path for each robot based on a specific sequence or priority i.e., the first path for $R_1$, the second path for $R_3$, and the third (last) path for $R_2$. There is an intersection (crossroad) between the paths of $R_1$ and $R_3$, and opposite directions on the graph edges (straight roads) between the paths of $R_3$ and $R_2$. However, no collision occurred as the algorithm has planned a path for each robot sequentially (one by one). Hence, when planning the following path, it considers all the paths that have already been scheduled to prevent collisions and keep ${\lambda }_2>0$. There is a crossroad when $R_1$ passes the edge$\left(v_6,v_{14}\right)$ and $R_3$ passes the edge$\left(v_{10},v_8\right)$, but no collision occurs as $R_1$ passes before $R_3$. The arrival time ${(T}_{R_n}=w_i+w_{ij})$of $R_1$when passed the vertex ($v_6)$is:$T_{R_1}=w_1+w_{\left(\mathrm{1,6}\right)}=2$, and once passed the vertex ($v_{14})$:$T_{R_1}=w_6+w_{\left(\mathrm{6,14}\right)}=4$. Whereas the arrival time of $R_3$ once passed the vertex ($v_{10})is$:$T_{R_3}=w_3+w_{\left(\mathrm{3,10}\right)}=4$, and when passed the vertex ($v_8)T_{R_3}=w_{10}+w_{\left(\mathrm{10,8}\right)}=7$. Consequently, $T_{R_1}<T_{R_3},\mathrm{w}\mathrm{h}\mathrm{i}\mathrm{c}\mathrm{h}\mathrm{m}\mathrm{e}\mathrm{a}\mathrm{n}\mathrm{s}$that the arrival time of $R_1$to the vertex $v_{14}$ is shorter than the arrival time of $R_3$ to the vertex $v_8,$ because the distance (edge weight) that $R_1$has passed the vertex $v_6=2$is less than the distance (edge weight) that $R_3$ has passed the vertex $(v_{10}=4)$ thus when $R_1$ arrives at the vertex ($v_{14}=4)$, $R_3$ arrives at the vertex $v_{10}$, for this reason, no collision occurs, and a change of the edge weight is not necessary. If$T_{R_1}>T_{R_3}$, then a collision is possible (i.e. if the arrival time of $R_1$on the vertex ($v_6=4$), then the change of the edge weight is necessary to avoid a collision. Also, there are opposite directions (straight paths) on the edge $\left(v_8,v_{10}\right)$ between$R_3$and $R_2$. $R_3$ passes the edge earlier than the $R_2$, where$T_{R_3}=\left\{\left(w_{10}+w_{\mathrm{10,8}}\right)=\left(4+3\right)=7\right\},$and $T_{R_2}={\left\{\right(w}_8+w_{\mathrm{8,10}})=(9+3)=12\}$. Thus, the arrival time of $R_3$once it passes the edge$\left(v_8,v_{10}\right)$is shorter than the arrival time of $R_2$ as the distance that $R_3$ has passed to arrive at the vertex$\left(v_8=7\right)$ is less than the distance that $R_2$has passed the vertex ($v_8)=9$. Thus, ${{(w}_8<T_{R_2})\wedge \left(w_{10}+w_{\left(\mathrm{10,8}\right)}<T_{R_2}\right),\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{n}T}_{R_2}>T_{R_3}$. In addition, there is a crossroad on the vertex ($v_8)$, where $T_{R_3}$ ${=w}_{10}+w_{\mathrm{10,8}}=7$, and $T_{R_2}$ ${=w}_{21}+w_{\mathrm{21,8}}=9$, hence $T_{R_3}{<T}_{R_2}$ the arrival time of $R_3$ to the vertex ($v_8)$ before $R_2$. Accordingly, there is no need to change the edge weight since no collision occurs. If$T_{R_3}>T_{R_2}$, then the collision happens, so the change of the edge weight is necessary to avoid a collision. These are highlighted in Table 1.

To further illustrate the process, the workspace environment is changed to Figure 7.

To apply the MRPPA, the workspace is represented as an undirected weighted graph, then divide it into two disconnected components of an undirected weighted graph using a VG such as Figure 8.

The graph $G=\left(V_i,E_j\right)$ in Figure 8 consists of vertices$V=\left\{v_1,..,v_{32}\right\}$, where the vertices $v_1,v_{31},\mathrm{a}\mathrm{n}\mathrm{d}{v}_{24}$ represent initial robot positions $S_i$=$\left({R_1=v}_1,{R_2=v}_{31},R_3=v_{24}\right)$ that marked with red, while the vertices$v_{19},v_{20},and{v}_{11}$represent goals positions$\left({g_1=v_{19},g_2=v}_{20},g_{3,}{=v}_{11}\right)$ that shown as green, E = {$e_1,\dots ,e_{70}$}, and there are five polygonal obstacles ($O_i,1\le i\le 5$). The second smallest eigenvalue of the graph has zero value (${\lambda }_2=0)$because the graph has two disconnected components. $R_2$ has a path to reach its target, whilst $R_1$and$R_3$ have their targets in the second components of undirected weighted. If an edge is added between the vertex $v_{10}$ and vertex$v_{15}$, then $R_3$ can find a path to reach its target $g_3$, and from this${\lambda }_2$ increases to 0.521. Also, if we add the edges$\left(v_1,v_8\right)$,$(v_8,v_{17}$), and$\left(v_{17},v_{19}\right).$This enables $R_1$ to find a path to reach its target$g_1$, and ${\lambda }_2$ increases to 1.275. Additionally, when adding all possible edges between the vertices of the graph, we created robust connectivity in the graph, and ${\lambda }_2$ increases to 2.855. The shortest paths are found using the Dijkstra’s algorithm, as shown in Figure 9 and Figure 10.

The MRPPA planned the first path for R3, the second path for R₁, and the third path for R₂. No collision occurred because the algorithm has controlled the arrival time of each robot by holding the weight of the edge (distance) and keeping ${\lambda }_2$>0.

4.1. Simulation Procedure

This section introduces the simulation setup, parameters, and results of implementing the MRPP algorithm. This algorithm leverages VG for obstacle avoidance, algebraic connectivity to maintain communication cohesion, and Dijkstra’s algorithm for optimal pathfinding.

Simulation Environment: The path planning software simulations were conducted in a MATLAB/Simulink environment version 2024 (The MathWorks, Inc. with the Robotics System Toolbox) [27], leveraging custom VG generation and pathfinding scripts. All required inputs were supplied to perform and complete the path planning process and follow a specific logical order. A 2D environment with static polygonal obstacles was devised, representing a workspace of dimensions (18 × 12) units, where each unit represented one-meter square. The obstacles were defined as geometric shapes such as triangles, rectangles, squares, zigzag lines, etc, and robots were modelled as points.

Parameters: Three robots (R₁, R₂, R₃) appearing as three red points were selected. Three goals (g₁, g₂, g₃) were represented by green points. The six randomly generated polygonal obstacles ($O_i,1\le i\le 6$) of varying sizes were highlighted in blue with different labels. Each robot was initialised at random start points and assigned unique goal positions. The algorithm’s effectiveness was evaluated in different scenarios with varying obstacles and number of robots. The performance metrics included path optimality and connectivity maintenance.

Motion Planning Approach: Each robot computed a visibility graph to represent possible paths around obstacles, connecting vertices (obstacles’ vertices, and start and goal points) with edges representing collision-free paths. Dijkstra’s algorithm was applied to find the shortest route to the goal for each robot. Algebraic connectivity was constantly measured, ensuring all robots remained within the communication range. Adjustments were made to the paths when the connectivity ${\lambda }_2$ = 0 or very small.

4.2. Results for the Simulation Scenarios

Scenario 1: Six obstacles, three robots marked red, three goals marked green are shown in Figure 11 and Figure 12.

In the first scenario, three robots were deployed highlighted with six obstacles density marked as blue. VG was established, and each robot’s path was computed using Dijkstra’s algorithm. The connectivity was maintained throughout the simulation. All robots successfully reached their goals as illustrated in Figure 13.

The simulation results using MATLAB show that the robots reached their targets, the path of R₁ is highlighted as yellow, the path of R₂ is highlighted as green, and the path of R₃ is highlighted as red as shown in Figure 14.

Scenario 2: Five obstacles, three robots highlighted as blue and three goals highlighted as green, see Figure 15 and Figure 16.

In scenario 2, three robots highlighted in blue, and three goals highlighted in green navigated an environment with obstacles. A VG was generated for each robot. Dijkstra’s algorithm was used to measure the distance for each robot. All robots reached their targets while maintaining connectivity, as shown in Figure 17.

The simulation result (Figure 18) shows that each robot has reached its target without a collision.

5. Discussion

The proposed multi-robot motion planning approach was evaluated through experiments using different environments with randomly placed obstacles and different robot configurations. Robots were assigned random start and goal locations, navigating through environments of varying obstacles. For each configuration, performance metrics included path length and the total distance that each robot travelled, i.e.,

• Computation of path: Calculating paths while maintain connectivity.
• Algebraic connectivity: A measure of communication robustness among robots.
• Success Rate: The robots reaching their targets without collisions or connectivity loss.

These metrics align with the previous studies such as [28], which emphasised path efficiency, robustness, and connectivity in multi-robot systems. The proposed paths contained two main components: a global planner and path optimisation. The global planner gathered information about the surrounding environment, such as the robot’s positions, targets, and obstacles. Depending on the path analysis, finding the path with minimum cost is necessary. When the optimal path is found with prior knowledge of the environment and static obstacles, a collision-free optimal path was created before the robots moved. One finding is that the proposed algorithm significantly improved the generation of efficient paths due to connectivity robustness, and robots reached their goals reliably without collisions.

In tests with three robots for connectivity maintenance, the MRPP effectively determined paths by analysing all possible routes and selecting the most suitable one based on the algebraic connectivity measure and the predefined weight evaluation function, indicating adaptability. The algorithm planned a sequential path for each robot one by one (i.e., path by path), considering all already planned paths to avoid collisions. The MRPP algorithm provided each robot's optimal (i.e., short-distance and safe) paths. The lengths, and motion times of the paths were based on the planning order. The choice of the correct sequence for the path planning of robots has a significant impact on the performance of the robot team. In the first scenario of workspace, ${\mathit{R}}_3$ has a path to reach its target: ${(\mathit{R}}_3\to {\mathit{v}}_4\to {\mathit{v}}_7{\to \mathit{v}}_{29}$), and the total distance is (20 m), see Figure 4. However, this path is not optimal and (${\mathit{\lambda }}_2$ = 0) meaning the graph is disconnected. Thus, for optimisation, the MRPPA re-calculated the path and examined the two best edges $\left({\mathit{v}}_8,{\mathit{v}}_{10}\right)$and$({\mathit{v}}_8,{\mathit{v}}_{17}$) to add between the graph components and measured algebraic connectivity. The algorithm found an optimal path for R₃ instead of the first path while maintaining ${\mathit{\lambda }}_2$ of the communication graph at a high level (for R₃, ${\mathit{R}}_3\to {\mathit{v}}_3\to {\mathit{v}}_{10}\to {{\mathit{v}}_8\to \mathit{v}}_{17}\to {\mathit{v}}_{13}\to {\mathit{v}}_{29})$. The total distance is (15 m), and (${\mathit{\lambda }}_2$ increases to 0.181), see Figure 5. Accordingly, the MRPPA chooses a path for each robot respectively to ensure that robots remain connected while performing their tasks and avoid collision avoidance. Ensuring connectivity among robots throughout their paths proved effective with algebraic connectivity. The system maintained an average algebraic connectivity value of 6.380 in Figure 4, indicating robust and consistent communication links due to recalculations that adaptively modified paths. This result is consistent with an earlier study [29], who demonstrated that multi-robot systems incorporating recalculation can effectively respond to real-time changes in their environment. This supports prior work by [30], highlighting algebraic connectivity’s effectiveness in maintaining communication in multi-robot networks and where connectivity is essential for coordinated robot actions [31].

The results demonstrated the visibility graph’s ability to avoid obstacles effectively while ensuring direct paths. This aligns with an earlier finding that reported similar results when comparing visibility-based methods with grid-based path planning in cluttered environments [32]. The VG method considers obstacles’ vertices in the map to be the vertices through which the robots can reach their required positions. It links the visible vertices with each other, where the visible vertices are vertices with the property that a straight line (edge, path) connecting them does not intersect with any obstacles. Therefore, the calculated paths contain a set of waypoints ($\widehat{\mathit{W}}$), with the shortest length. These waypoints are determined like a series of consecutive points which begin from the lowest number of the first point to the goal number; the waypoints are given by $\widehat{\mathit{W}}=\{{\mathit{w}}_0,.....,{\mathit{w}}_{\mathit{n}}\},$ where ${\mathit{w}}_0$ is the starting point, and ${\mathit{w}}_{\mathit{n}}$ is the goal point. Hence, waypoints are a set of vertices of obstacles. For this reason, the paths have the least distances because they contain a set of waypoints, which are a set of vertices found by using VG with a combination of Dijkstra’s algorithm. These waypoints do not include the start points and the goal points, so they are always at specific vertices of obstacles. Thus, they can produce the shortest paths in terms of the Euclidean distance, the essential condition for a path to have a lower Euclidean distance from the starting point to the goal point in C-space, where each waypoint is a vertex of an obstacle. In robotics, the configuration space (often abbreviated as C-space) is a conceptual framework that represents all possible positions and orientations of a robot within its environment.

The proposed algorithm provided an efficient and robust solution for multi-robot motion planning. The work showcased notable benefits in path optimality and connectivity, providing reliable routes. This makes it well-suited for environments where efficient path planning and dependable connectivity are essential [33]. Consequently, this method is more effective for applications that require continuous communication, such as collaborative robotics and autonomous logistics [34]. The simulation results also indicated that the proposed approach is practical for multi-robot motion planning in different environments. In comparison, the VG method with Dijkstra’s algorithm generates pathfinding and provides efficient optimal paths in pathfinding applications. This approach allows for the computation of the shortest paths that navigate around obstacles effectively [35]. In addition, the connectivity constraints provided by algebraic connectivity enable a more resilient, robust communication framework, and it serves as an indicator of a network's overall connectedness, facilitating better synchronization and coordination among robots. This improvement in connectivity is valuable for applications requiring continuous communication, such as coordinated robotic systems in automated warehouses [36,37]. Our approach exhibited clear advantages in optimal path efficiency and robust connectivity, potentially enabling faster, safer, and more efficient operations in real-world applications [38].

6. Conclusions

This article presents a novel path-planning algorithm (MRPP) in a 2D static environment. Our algorithm successfully balanced path length optimisation with the maintenance of communication between robots. It provided efficient and coordinated navigation in environments with obstacles while avoiding collision. Simulation results demonstrated the effectiveness of the proposed algorithm, which efficiently navigated multiple robots in environments while ensuring robust communication. Although MRPPA has generated promising results in different scenarios and experiments, it can be computationally expensive when the environments are rich in obstacles. Therefore, investigations can be undertaken to improve MRPPA’s performance. Future work could also involve extending this approach to dynamic environments and a more significant number of robots as well as enhancing computation speed by optimising the VG construction or implementing parallel processing.