In recent years, quadcopters have gained significant attention due to their high efficiency, low cost, and adaptability to diverse missions, such as military reconnaissance, logistics, agricultural monitoring, and environmental protection. Path planning is a critical aspect of ensuring that quadcopters safely and efficiently complete designated tasks, requiring the generation of collision-free flight paths from a start point to a target while minimizing energy consumption under various constraints. Traditional path planning algorithms, including randomized roadmaps, artificial potential fields, and RRT*, often struggle with computational complexity and fail to deliver high-quality solutions in complex three-dimensional environments. To address these limitations, swarm intelligence algorithms, such as particle swarm optimization and grey wolf optimization, have been employed. However, these methods can be prone to local optima and slow convergence. In this paper, we propose an improved event-triggered grey wolf optimization algorithm for quadcopter three-dimensional path planning. Our approach incorporates spherical vectors to characterize flight path generation, reducing the search space and enhancing exploration capabilities. We design an adaptive weighting scheme to dynamically adjust the fitness function, improving planning efficiency and accuracy. Additionally, we introduce a nonlinear convergence factor to enhance robustness and integrate an event-triggered mechanism to balance global and local search by controlling the update velocity of grey wolf individuals. Simulation results demonstrate that our algorithm outperforms existing variants in terms of path quality and convergence stability.
The three-dimensional path planning problem for quadcopters is formulated as an optimization task where the goal is to minimize a cost function that encompasses path length, flight height, threat avoidance, and smoothness. We model the environment using a digital elevation model and represent obstacles as cylindrical regions. Each flight path is encoded as a sequence of spherical vectors, defined by radius, elevation angle, and azimuth angle, which directly incorporate turning and climbing constraints. This representation reduces the dimensionality of the search space and facilitates efficient exploration. The overall fitness function is a weighted sum of multiple cost components, with adaptive weights adjusted based on the performance of individuals during optimization. This ensures a balanced consideration of various constraints and enhances the algorithm’s ability to find feasible and optimal paths for quadcopter operations.
Our proposed event-triggered grey wolf optimization algorithm builds upon the standard grey wolf optimizer by introducing several key improvements. The nonlinear convergence factor allows for better control over the exploration-exploitation trade-off, while the event-triggered mechanism selectively updates the velocity of grey wolf individuals based on changes in the alpha wolf’s fitness. This reduces unnecessary computations and accelerates convergence. The position update strategy leverages spherical vectors to map the quadcopter’s motion parameters directly to the search space, ensuring that generated paths satisfy kinematic constraints. We evaluate our algorithm in simulated environments with realistic terrain and obstacles, comparing it against other grey wolf variants. The results show that our method consistently produces shorter, smoother, and safer paths, demonstrating its superiority in complex scenarios.
Three-Dimensional Path Planning Model for Quadcopter
In quadcopter path planning, the objective is to generate a flight path from a start point to an end point that avoids obstacles and minimizes cost. We represent a path as a sequence of waypoints in three-dimensional space, each defined by coordinates $P_{i,j} = (x_{i,j}, y_{i,j}, z_{i,j})$ for $j = 1, 2, \ldots, N$, where $N$ is the number of waypoints. To efficiently capture the quadcopter’s motion, we use spherical vectors $S_{i,j} = (r_{i,j}, \phi_{i,j}, \theta_{i,j})$, where $r_{i,j} \in (0, L)$ is the radius, $\phi_{i,j} \in (-\pi/2, \pi/2)$ is the elevation angle, and $\theta_{i,j} \in (-\pi, \pi)$ is the azimuth angle. These vectors describe the movement from one waypoint to the next, and the Cartesian coordinates are derived as follows:
$$x_{i,j+1} = x_{i,j} + r_{i,j} \sin \phi_{i,j} \cos \theta_{i,j}$$
$$y_{i,j+1} = y_{i,j} + r_{i,j} \sin \phi_{i,j} \sin \theta_{i,j}$$
$$z_{i,j+1} = z_{i,j} + r_{i,j} \cos \phi_{i,j}$$
The environment is modeled using a digital elevation model to represent terrain elevation and cylindrical obstacles. The $k$-th obstacle region $A_k$ is defined by its center $(x_k, y_k)$, radius $R_k$, and height $h_k$, with the mathematical representation:
$$(x – x_k)^2 + (y – y_k)^2 = R_k^2, \quad z \in [0, h_k]$$
Boundary constraints are applied to restrict the quadcopter’s operating area:
$$x_{i,j} \in [1, x_{\text{max}}], \quad y_{i,j} \in [1, y_{\text{max}}], \quad z_{i,j} \in [h_{\text{min}}(DEM), z_{\text{max}}]$$
The fitness function for evaluating a path $P_i$ is a weighted sum of four cost components: path length, flight height, threat, and smoothness. The path length cost $F_1(P_i)$ is the total distance traveled:
$$F_1(P_i) = \sum_{j=1}^{N-1} \| P_{i,j+1} – P_{i,j} \| = \sum_{j=1}^{N-1} r_{i,j}$$
The flight height cost $F_2(P_i)$ penalizes deviations from a desired height range $[h_{\text{min}}, h_{\text{max}}]$:
$$f(P_{i,j}) = \begin{cases}
\frac{|h_{\text{min}} + h_{\text{max}}|}{2}, & \text{if } h_{\text{min}} \leq h_{i,j} \leq h_{\text{max}} \\
\infty, & \text{otherwise}
\end{cases}$$
$$F_2(P_i) = \sum_{j=1}^{N} f(P_{i,j})^2$$
The threat cost $F_3(P_i)$ accounts for proximity to obstacles, with $d_k$ being the distance from the quadcopter to the $k$-th obstacle center, $D = d_{\text{quadcopter}} + d_{\text{threat}} + R_k$, and $d_{\text{quadcopter}}$ and $d_{\text{threat}}$ representing the quadcopter size and safety margin, respectively:
$$T_k(P_{i,j}, P_{i,j+1}) = \begin{cases}
0, & \text{if } d_k > D \\
\frac{D – d_k}{D – (d_{\text{quadcopter}} + R_k)}, & \text{if } d_{\text{quadcopter}} + R_k < d_k \leq D \\
\infty, & \text{if } d_k \leq d_{\text{quadcopter}} + R_k
\end{cases}$$
$$F_3(P_i) = \sum_{j=1}^{N-1} \sum_{k=1}^{K} T_k(P_{i,j}, P_{i,j+1})$$
The smoothness cost $F_4(P_i)$ incorporates turning angles $\phi_{i,j}$ and climbing angles $\psi_{i,j}$ to ensure feasible maneuvers:
$$\phi_{i,j} = \arctan\left( \frac{\| (P_{i,j} – P_{i,j-1}) \times (P_{i,j+1} – P_{i,j}) \|}{\| (P_{i,j} – P_{i,j-1}) \cdot (P_{i,j+1} – P_{i,j}) \|} \right)$$
$$\psi_{i,j} = \arctan\left( \frac{|z_{i,j+1} – z_{i,j}|}{\| (x_{i,j+1} – x_{i,j}, y_{i,j+1} – y_{i,j}) \|} \right)$$
$$F_4(P_i) = p_1 \sum_{j=2}^{N-1} |\phi_{i,j} – \phi_{i,j-1}| + p_2 \sum_{j=2}^{N-1} |\psi_{i,j} – \psi_{i,j-1}|$$
The overall fitness function $F(P_i)$ uses adaptive weights $w_k$ that adjust based on the relative performance of each cost component:
$$F(P_i) = \sum_{k=1}^{4} w_k F_k(P_i), \quad w_k = 1 – \frac{1}{3} \left( \frac{F_k(P_i)}{\sum_{l=1}^{4} F_l(P_i)} \right)$$
This adaptive weighting scheme ensures that the optimization process dynamically prioritizes cost components, leading to more balanced and efficient path planning for the quadcopter.
Event-Triggered Grey Wolf Optimization Algorithm
The grey wolf optimization algorithm is a swarm intelligence technique inspired by the social hierarchy and hunting behavior of grey wolves. It classifies individuals into alpha, beta, delta, and omega wolves, representing the best, second-best, third-best, and candidate solutions, respectively. The standard algorithm involves encircling prey and updating positions based on the leaders. However, it suffers from parameter sensitivity and local optima convergence. Our improved event-triggered grey wolf optimization algorithm addresses these issues by incorporating a nonlinear convergence factor and an event-triggered velocity update mechanism.
We encode each path as a set of spherical vectors $P_i = (r_{i,1}, \phi_{i,1}, \theta_{i,1}, \ldots, r_{i,n}, \phi_{i,n}, \theta_{i,n})$ for $n = N-1$ segments. The position of a grey wolf individual is represented as $S_{i,j} = (r_{i,j}, \phi_{i,j}, \theta_{i,j})$, and the update velocity is defined as $V_{i,j} = (\Delta r_{i,j}, \Delta \phi_{i,j}, \Delta \theta_{i,j})$. The nonlinear convergence factor $a$ is given by:
$$a = a_m \left(1 – \frac{1 – e^{-k t / T_{\text{max}}}}{1 – e^{-k}}\right)$$
where $a_m$ is the initial value, $k$ is a tuning parameter, $t$ is the current iteration, and $T_{\text{max}}$ is the maximum iterations. This factor allows for rapid global exploration initially and finer local search later.
The event-triggered mechanism controls the velocity update based on changes in the alpha wolf’s fitness. Let $E_{\alpha} = F(\alpha)$, $E_{\beta} = F(\beta)$, and $E_{\delta} = F(\delta)$ be the fitness values of the alpha, beta, and delta wolves, respectively. The total fitness $E = E_{\alpha} + E_{\beta} + E_{\delta}$ is used to compute adaptive weights $\tau_l$ for the leaders:
$$\tau_l = \frac{E – E_l}{2E}, \quad l = 1,2,3$$
The velocity update equation incorporates these weights and a random component:
$$V_{i,j}^{t+1} = \lambda V_{i,j}^t + \tau_1 r_1 (S_1 – S_{i,j}^t) + \tau_2 r_2 (S_2 – S_{i,j}^t) + \tau_3 r_3 (S_3 – S_{i,j}^t)$$
where $\lambda$ is the inertia weight, $r_1, r_2, r_3$ are random numbers in $[0,1]$, and $S_1, S_2, S_3$ are the positions guided by the alpha, beta, and delta wolves, calculated as:
$$D_{\alpha} = |C_1 \cdot X_{\alpha} – X^t|, \quad D_{\beta} = |C_2 \cdot X_{\beta} – X^t|, \quad D_{\delta} = |C_3 \cdot X_{\delta} – X^t|$$
$$S_1 = X_{\alpha} – A_1 \cdot D_{\alpha}, \quad S_2 = X_{\beta} – A_2 \cdot D_{\beta}, \quad S_3 = X_{\delta} – A_3 \cdot D_{\delta}$$
$$A_l = 2a r_l – a, \quad C_l = 2 r_l’, \quad l=1,2,3$$
The event trigger condition $e$ is defined as the difference in alpha wolf fitness between consecutive iterations:
$$e = \max(F(\alpha^t) – F(\alpha^{t-1}), 0), \quad t \geq 2$$
If $e = 0$, the velocity is updated; otherwise, it remains unchanged:
$$V_{i,j}^{t+1} = \begin{cases}
\text{Equation (15)}, & \text{if } e = 0 \\
V_{i,j}^t, & \text{if } e \neq 0
\end{cases}$$
The position update is then performed using the velocity:
$$S_{i,j}^{t+1} = S_{i,j}^t + V_{i,j}^{t+1}$$
This approach reduces unnecessary computations and enhances convergence by focusing updates on significant fitness improvements. The algorithm pseudocode is summarized as follows:
Input: Grey wolf population $S$, population size $N_s$, problem dimension $D_s$, maximum iterations $T_{\text{max}}$, constraints $C$.
Algorithm:
1. Initialize population and compute fitness.
2. Identify alpha, beta, and delta wolves.
3. While $t < T_{\text{max}}$:
a. Update convergence factor $a$ using Equation (11).
b. For each individual $i$ and dimension $j$:
i. Compute $S_1, S_2, S_3$ using Equations (17)-(18).
ii. Calculate event trigger $e$ using Equation (19).
iii. Update velocity $V_{i,j}^{t+1}$ based on $e$.
iv. Update position $S_{i,j}^{t+1}$ using Equation (21).
c. Recompute fitness and update alpha, beta, delta wolves.
d. Increment $t$.
4. Output global best solution.
This algorithm ensures efficient path planning for quadcopters by leveraging spherical vectors and event-triggered updates, leading to improved performance in complex environments.
Simulation Experiments and Comparative Analysis
We conducted simulation experiments to evaluate the performance of our event-triggered grey wolf optimization algorithm for quadcopter path planning. The environment was based on a real digital elevation model with dimensions 1000 m × 850 m × 400 m. Six cylindrical obstacles were placed with centers at [(380, 250, 150), (400, 600, 100), (500, 450, 150), (600, 250, 150), (650, 750, 150), (700, 550, 150)] and radii [70, 80, 80, 70, 80, 70]. The start point was (100, 100, 100), and the end point was (800, 800, 150). We compared our algorithm against three variants: standard linear GWO (SLGWO), standard nonlinear GWO (SNGWO), and a hybrid particle swarm-GWO (SHGWO). All algorithms used a population size of 500 and maximum iterations of 200, with 20 independent runs for statistical reliability.
The table below presents the mean and standard deviation of the fitness values for paths with 12 and 22 waypoints, corresponding to 10 and 20 path segments, respectively. Our ETGWO algorithm achieved the lowest mean fitness values in both cases, indicating superior path quality and consistency.
| Algorithm | n=12 Mean | n=12 Std | n=22 Mean | n=22 Std |
|---|---|---|---|---|
| ETGWO | 764.57 | 14.27 | 763.09 | 8.26 |
| SHGWO | 767.20 | 12.68 | 767.46 | 8.58 |
| SNGWO | 807.32 | 32.26 | 801.07 | 17.94 |
| SLGWO | 831.24 | 46.28 | 802.49 | 11.58 |
The convergence curves show that ETGWO consistently reaches lower fitness values faster than other algorithms, thanks to the event-triggered mechanism and nonlinear convergence factor. For $n=12$, ETGWO reduced the fitness to around 765 within 50 iterations, while SHGWO required more iterations to achieve similar results. For $n=22$, ETGWO maintained stable convergence with minimal variance, outperforming others in both exploration and exploitation. The generated paths were feasible, avoiding obstacles and adhering to height constraints, with smooth turns and climbs. The spherical vector representation directly enforced kinematic constraints, resulting in paths that are practical for real quadcopter operations.
In terms of computational efficiency, ETGWO reduced the number of velocity updates by 30-40% compared to standard GWO, as the event trigger skipped updates when fitness improvements were negligible. This saving is crucial for real-time path planning applications where quadcopters must quickly adapt to dynamic environments. The adaptive weighting in the fitness function also contributed to better performance by prioritizing critical cost components during different optimization stages.
Conclusion
In this paper, we presented an event-triggered grey wolf optimization algorithm for quadcopter three-dimensional path planning. Our approach addresses the limitations of traditional methods by integrating spherical vectors for path representation, adaptive weights for fitness evaluation, a nonlinear convergence factor for robustness, and an event-triggered mechanism for efficient updates. The spherical vectors enable direct mapping of quadcopter motion parameters, reducing search space and ensuring constraint satisfaction. The event-triggered velocity update balances global and local search, reducing computational overhead and accelerating convergence. Simulation results in complex environments demonstrate that ETGWO produces shorter, smoother, and safer paths compared to other grey wolf variants, with consistent performance across different path lengths.
Future work will focus on extending the algorithm to dynamic environments where obstacles move or appear unexpectedly. We plan to incorporate real-time sensor data and machine learning techniques to enhance adaptability. Additionally, we will explore multi-quadcopter coordination for collaborative tasks, such as swarm operations, where path planning must consider inter-agent collisions and communication constraints. The event-triggered mechanism could be further refined to handle asynchronous updates in distributed systems. Overall, our algorithm provides a robust foundation for advanced quadcopter applications, contributing to the growing field of autonomous aerial robotics.