Efficient Trajectory Planning for Drone-Based Logistics: A JPS–Bresenham and Ellipsoid-Based Safe Corridor Approach

Highlights

What are the main findings?

• We propose a JPS–Bresenham path search method for efficient waypoint reduction.
• We design safe flight corridors with overlapping convex polyhedra via ellipsoid fitting.

What are the implications of the main findings?

• The proposed hierarchical framework enables computationally efficient, smooth, and dynamically feasible trajectory planning for quadrotors, with strong applicability in drone-based logistics delivery across complex low-altitude urban environments.

Abstract

Quadrotor motion planning in cluttered environments presents significant challenges in achieving both computational efficiency and trajectory smoothness, particularly in low-altitude economy and intelligent energy system applications where autonomous aerial vehicles perform infrastructure inspection and power line monitoring. Many existing methods either rely on sampling-based algorithms that suffer from long computation times and suboptimal paths, or employ trajectory representations that produce high-order derivative discontinuities unsuitable for agile flight. In this work, we propose an efficient hierarchical motion planning framework that integrates a JPS–Bresenham-based path search with safe flight corridor construction and Bézier curve optimization. Our approach addresses trajectory generation through a two-stage process: a front-end path search that efficiently identifies collision-free paths with reduced waypoints, followed by a back-end optimization that leverages convex safe corridors with overlapping regions to expand the solution space. Through comprehensive benchmark experiments across six different map scenarios, we demonstrate that our method outperforms RRT* and PRM in both path quality and computational efficiency. Monte Carlo experiments across varying map sizes and obstacle densities confirm robustness and scalability advantages. Comparative studies with state-of-the-art planners demonstrate superior success rates and cost efficiency while maintaining strict kinodynamic feasibility. The Bézier-based optimization reduces snap integral by up to 55% compared to ordinary polynomial approaches, demonstrating its superiority for fast quadrotor trajectory planning in complex environments.

1. Introduction

The low-altitude economy refers to emerging economic activities utilizing airspace below 1000 m for commercial applications, including logistics delivery, infrastructure inspection, and emergency response. The swift rise of this domain, coupled with the expanding adoption of smart logistics frameworks, has accelerated the widespread integration of UAVs into time-sensitive, on-demand delivery operations. Within this context, quadrotor drones are regarded as key enablers for flexible, high-frequency distribution in urban airspace, complementing or even partially substituting traditional ground-based transportation. Emerging research across freight and distribution networks has comprehensively examined the opportunities and limitations of drone adoption within modern supply operations, highlighting their role in reducing delivery time and enhancing flexibility while also stressing regulatory and safety concerns [1]. Complementary investigations have catalogued and ranked the key obstacles hindering UAV-based freight deployment—such as regulatory uncertainty, privacy and security risks, and public acceptance—as critical factors that must be addressed before low-altitude drone logistics can scale up [2]. At the operational level, hyperlocal and on-demand delivery platforms have motivated optimisation models for drone-based last-mile services, where mixed-integer programming is used to design cost-effective drone delivery strategies in dense urban markets [3].

In parallel, a broader stream of research on UAV-based logistics has examined application scenarios, routing decisions and sustainability issues from an operations and policy perspective. Extensive surveys of the UAV logistics literature highlight the benefits of unmanned aerial vehicles with respect to flexibility, low operating cost and environmental benefits, but also point out that most works focus on routing and scheduling at the network level rather than on the kinodynamically feasible motion of individual vehicles [4,5]. From a last-mile standpoint, systematic literature reviews on drone-based delivery underline the research gap between high-level planning models and the physical feasibility of flight in cluttered, low-altitude urban environments, especially when responsive reactivity and safety constraints are considered [6]. In the urban airspace context specifically, recent work has demonstrated that simultaneously accounting for drone kinodynamics, power consumption, and collision-free navigation within an integrative path-planning framework is essential for practical logistics deployment of multi-rotor platforms [7]. Furthermore, particle-swarm-optimisation-based approaches have been developed to handle the complex cost landscape of UAV path planning in urban airspace, showing that metaheuristic methods can effectively balance safety constraints, path length, and energy expenditure [8]. Consequently, there is a clear need to bridge logistics-oriented planning frameworks with motion-planning methods that explicitly account for the dynamics, energy constraints and onboard computational limits of quadrotors operating in intelligent logistics systems. Key technical concepts in this context include kinodynamic feasibility (ensuring trajectories respect vehicle dynamics constraints), minimum-snap optimization (minimizing the fourth derivative of position for smooth trajectories), and safe flight corridors (convex representations of collision-free space).

From a UTM integration perspective, our hierarchical framework offers specific advantages for tactical-level trajectory planning under airspace management constraints. The safe flight corridor construction can directly incorporate geofencing boundaries as additional constraint polyhedra, while the JPS–Bresenham search enables rapid replanning when strategic deconfliction parameters or temporary flight restrictions change. This computational efficiency allows real-time adjustment to traffic coordination commands, making our method suitable for deployment within UTM systems where regulatory compliance and dynamic airspace allocation are essential requirements.

On the motion-planning side, minimum-snap trajectory generation has become a fundamental tool for quadrotors. Mellinger and Kumar [9] pioneered a polynomial-spline formulation that minimises snap, achieving highly smooth trajectories suitable for aggressive manoeuvres in constrained environments; however, the resulting quadratic programs become computationally demanding as the number of segments grows, and the method does not explicitly target energy-efficient flight. Subsequent work on fast minimum-snap computation has improved numerical scalability and enabled trajectories with very large numbers of segments [10], yet these approaches typically assume that a collision-free waypoint sequence is already available and still treat obstacle avoidance and dynamic feasibility in a decoupled manner. To address kinodynamic feasibility more directly, motion-primitive-based frameworks have been proposed that precompute libraries of dynamically feasible manoeuvres and deploy them within a graph-search scheme, yielding collision-free trajectories that respect quadrotor dynamics at reduced runtime cost [11]. To better handle cluttered environments, Zhou et al. proposed safe-flight-corridor based trajectory optimisation, where overlapping convex polyhedra are used to guarantee collision avoidance during high-speed flight, but the underlying optimisation remains relatively heavy for onboard deployment and often relies on heuristics for time allocation [12]. Online motion-planning frameworks such as those by Gao et al. reduce the strictness of optimality requirements in order to meet time-sensitive constraints [13], yet they may lead to conservative trajectories with suboptimal smoothness and energy efficiency, which is undesirable for logistics drones with limited battery capacity. Despite these advances, three critical limitations persist: (1) existing methods often decouple path search from trajectory optimization, leading to suboptimal solutions; (2) safe corridor construction remains computationally expensive for real-time applications; and (3) traditional polynomial representations require iterative constraint verification, creating computational bottlenecks. These limitations motivate the need for an integrated framework that simultaneously addresses path efficiency, corridor construction, and trajectory optimization.

Moreover, many existing logistics-oriented UAV path-planning models either rely on simplified kinematic constraints or assume deterministic flight times and energy consumption, which can underestimate the risk of infeasible or unsafe trajectories in complex low-altitude airspace [4,5]. As a result, there remains a gap between (i) high-level optimisation of drone routes and service strategies for low-altitude intelligent logistics, and (ii) low-level generation of collision-free, dynamically feasible and energy-conscious trajectories that can be computed within tight time budgets.

To address these gaps, this work develops an integrated hierarchical planning framework that explicitly bridges the disconnect between high-level logistics planning and low-level trajectory generation. Unlike prior work that treats these components in isolation, our approach simultaneously optimizes path search, corridor construction, and trajectory generation while maintaining computational efficiency. We make the following algorithmic and theoretical contributions:

• JPS–Bresenham integration with theoretical bounds: We propose a theoretically grounded path search method combining JPS with Bresenham-based collision detection. We derive the upper bound on waypoint reduction and prove that the method maintains path optimality while achieving 67.3% average waypoint reduction compared to standard JPS.
• Efficient ellipsoid fitting with bounded complexity: We design a safe-flight-corridor generation scheme with provable convergence properties. The introduction of bounding boxes reduces obstacle search complexity by half while maintaining corridor volume, as validated through theoretical analysis and experimental comparison.
• Linear constraint transformation for Bézier-based optimization: Instead of conventional piecewise polynomials, we employ Bézier curves and provide explicit mathematical derivation showing how non-convex corridor constraints can be transformed into linear inequalities on control points. This reduces the optimization from non-convex to convex quadratic programming, achieving 40–55% reduction in snap integral and 30–45% faster computation.

In summary, by integrating an efficient JPS–Bresenham search, ellipsoid-based safe flight corridors, and Bézier-curve trajectory optimisation with practical time-allocation schemes, this work provides a motion-planning framework that better aligns with the requirements of low-altitude economic development and intelligent logistics systems, where safety, energy efficiency and computational responsiveness are all critical performance metrics.

2. Related Work

The emergence of low-altitude economy and intelligent logistics systems has catalyzed significant research in autonomous aerial vehicle operations. As quadrotor drones become integral to urban logistics and infrastructure inspection, efficient and safe motion planning has become increasingly critical for rapid autonomous maneuvering in cluttered surroundings.

2.1. UAV Motion Planning for Low-Altitude Logistics Operations

The rapid advancement of low-altitude economy applications has driven substantial research in UAV motion planning and trajectory optimization for logistics operations. Recent comprehensive reviews have systematically examined UAV path planning techniques across diverse applications, highlighting the importance of energy-efficient algorithms that dynamically adjust flight parameters based on real-time power availability [14]. In the context of autonomous package delivery, integrated path planning and trajectory tracking frameworks have been proposed to achieve fast performance while ensuring collision avoidance in cluttered environments [15]. For logistics collection missions, trajectory design methods combining worldwide route planning with locally trained collision-conscious continuous trajectories have shown notable gains in mission time efficiency [16].

Motion planning for maneuverable fixed-wing UAVs operating in cluttered near-ground environments has been addressed through differential flatness properties and aggressive flight path generation [17]. The technical review of autonomous aerial robotics for package delivery emphasizes the critical balance between vehicle weight reduction for high-speed maneuvering, enhanced sensing capabilities for long-range obstacle detection, and advanced planning algorithms that maximize flight speed while maintaining safety guarantees [18]. Survey studies on UAV motion planning have systematically categorized planning frameworks as two-stage pipelines comprising initial discrete route search and subsequent continuous trajectory refinement, emphasizing the necessity of generating kinodynamically feasible trajectories through proper time parameterization [19]. Recent advances in real-time trajectory planning have focused on Class II and Class III UAVs conducting autonomous operations beyond line of sight, where flyability, real-time performance, and embedded computational capabilities become paramount considerations [20].

Despite these advances, existing methods exhibit distinct performance characteristics under different conditions. Sampling-based planners like RRT* perform well in high-dimensional spaces but suffer from high computation times that become prohibitive for time-critical logistics applications with dense obstacles. Grid-based search methods guarantee optimality and perform efficiently in sparse environments but produce paths with redundant waypoints that increase optimization complexity, particularly in cluttered urban environments. These limitations motivate the development of more efficient hierarchical frameworks that leverage aggressive node pruning in path search and convex-hull-based constraint checking in trajectory optimization.

2.2. Safe Flight Corridor Construction and Trajectory Optimization

Safe flight corridors provide convex representations of collision-free space that enable efficient trajectory optimization while guaranteeing obstacle avoidance. By decomposing free space into overlapping convex regions (polyhedra or spheres), the non-convex planning problem transforms into tractable convex optimization. Existing approaches can be categorized into three classes:

(1) Polyhedra-based methods use overlapping convex polyhedra from ellipsoid inflation [21], providing tight approximations suitable for cluttered environments but requiring expensive iterative computation. Extensions include multi-agent scenarios [22], fixed-wing applications [23], and hierarchical frameworks [24].

(2) Sphere/bubble-based methods generate spherical corridors with large overlaps for high-speed navigation [25], excelling in dynamic environments due to geometric simplicity but producing conservative corridors in confined spaces. The SUPER system achieves velocities exceeding 5 m/s [26].

(3) Spline-based methods leverage curve properties for direct constraint enforcement. Bézier curves enable efficient constraint verification via convex hull properties, ideal for offline optimization [27], while B-splines provide local control for online replanning [28]. Recent advances include velocity-aware planning [29] and comparative validation of Bézier robustness [30].

2.3. Learning-Based Trajectory Planning

Beyond traditional optimization-based approaches, learning-based methods have emerged as an alternative paradigm for UAV trajectory planning. Reinforcement learning techniques enable agents to learn planning policies through trial-and-error interaction with environments, demonstrating potential for handling complex, high-dimensional decision spaces without explicit environment models [31]. Imitation learning approaches attempt to mimic expert demonstrations, potentially capturing nuanced planning strategies that are difficult to encode analytically [32]. Despite showing promise in controlled simulation environments, learning-based methods face significant challenges for practical logistics deployment: they typically require extensive training data that may not generalize well to diverse operational environments, lack the theoretical guarantees on safety and constraint satisfaction that optimization-based methods provide, and often exhibit poor interpretability—a critical concern for safety-critical aviation applications. Furthermore, the computational overhead of inference and the difficulty of incorporating hard constraints (such as geofencing boundaries or dynamic feasibility) remain open challenges.

Three critical limitations persist: (1) corridor construction lacks bounded complexity guarantees for cluttered environments; (2) path search, corridor generation, and optimization are treated separately without theoretical integration; (3) no unified framework systematically combines efficient waypoint reduction, provably convergent corridor construction, and convex optimization with strict kinodynamic constraints. Our work addresses these gaps through an integrated hierarchical framework specifically designed for low-altitude logistics operations.

3. Method

The low-altitude economy presents unique challenges for quadrotor motion planning in logistics operations, where drones must navigate complex urban environments while satisfying strict requirements for computational efficiency, trajectory smoothness, and dynamic feasibility. Traditional approaches struggle to balance these objectives: sampling-based methods suffer from excessive computation times, while conventional polynomial representations require iterative constraint verification that creates computational bottlenecks for time-critical missions.

In response to the aforementioned challenges, the present study introduces a unified hierarchical planning framework. First, we develop a JPS–Bresenham-based front-end path search that efficiently identifies collision-free paths while aggressively pruning redundant waypoints. Second, we construct overlapping safe flight corridors through ellipsoid fitting and convex polyhedra generation, with trapezoidal velocity profiles for time allocation. Third, we perform Bézier curve-based trajectory optimization, leveraging convex hull properties to reformulate constraints as linear inequalities on control points. We validate our framework through comprehensive experiments across six map scenarios with varying obstacle densities, demonstrating superior performance in path efficiency, computational speed, and trajectory smoothness. Key innovations include (1) JPS–Bresenham integration with theoretical bounds on waypoint reduction, (2) bounding box acceleration for ellipsoid fitting, and (3) linear constraint transformation enabling convex optimization.

3.1. Motion Planning Framework for Low-Altitude Drone Logistics

This paper designs a hierarchical quadrotor motion planning framework as shown in Figure 1. The framework consists of three sequential modules:

Module 1 (Front-End Path Search): Takes as input a 3D grid map with obstacles, start position ${\mathbf{p}}_{\mathrm{start}}\in {\mathbb{R}}^3$, and goal position ${\mathbf{p}}_{\mathrm{goal}}\in {\mathbb{R}}^3$. Performs JPS–Bresenham-based path search to output a collision-free waypoint sequence. The waypoint reduction simplifies subsequent corridor construction.

Module 2 (Safe Corridor Construction): Takes the waypoint sequence as input and constructs safe flight corridors through ellipsoid fitting with bounding box acceleration [21] and convex polyhedra generation [33]. Adjacent corridors overlap to increase solution space flexibility. Trapezoidal velocity profile-based time allocation [34] assigns time duration to each segment.

Module 3 (Back-End Trajectory Optimization): Takes safe corridors and time allocation as input, along with kinodynamic constraints. Performs Bézier curve-based optimization [35], leveraging convex hull properties to transform non-convex corridor constraints into linear inequalities on control points, outputting a smooth trajectory.

The modules are tightly integrated: reduced waypoints from Module 1 decrease corridor construction complexity in Module 2, while convex corridors from Module 2 enable efficient optimization in Module 3.

The above block diagram reveals that the drone motion planning framework consists of three primary parts. The following sections analyze each of the above steps to quickly obtain a desired trajectory that meets the drone’s kinematic constraints and is smooth and collision-free.

3.2. JPS–Bresenham-Based Front-End Path Search

3.2.1. JPS Jump Point Search Algorithm

The JPS jump point search algorithm [36] is a pathfinding algorithm designed for uniform grids and is an improved version of the A* algorithm. The A* algorithm mainly consists of two steps: first, expansion, which calculates the heuristic evaluation values of all neighboring nodes from the starting point and adds the neighboring nodes to a list, followed by optimization, which selects the node with the smallest heuristic evaluation value from the list for the next round of expansion. By continuously repeating the expansion and optimization steps, the optimal path from the starting point to the end point can be found. The A* algorithm adopts a strategy of gradually expanding adjacent nodes. When the map is large, this strategy requires evaluation and optimization of a large number of nodes on the path, which can easily become a performance bottleneck. The JPS jump point search algorithm targets farther and more critical nodes on the path for expansion, thus reducing overhead. The algorithm finds critical jump points on the path, and only jump points are evaluated and optimized, while redundant nodes between jump points are filtered out. The number of nodes requiring evaluation and optimization is greatly reduced, improving algorithm efficiency. In addition, the JPS jump point search algorithm uses neighbor pruning to avoid adjacent parent–child nodes processing common neighbors, thus avoiding multiple equivalent paths.

The following are some important definitions in the JPS jump point search algorithm:

• Forced Neighbor: When there is an obstacle among the eight neighbors of node x, and the parent node p of node x reaches node n through node x with a distance cost that is always less than reaching node n without going through node x, then node n is called a forced neighbor of node x.
• Inferior Node: If the distance cost from parent node p to node n without going through current node x is less than or equal to the distance cost from parent node p to node n through current node x, then node n is called an inferior node.
• Natural Node: A node that can only be reached through child node x is a natural node.

Figure 2 shows the situation of reaching the current node from the parent node in a grid map when there are no obstacles in the map, divided into straight and diagonal cases. The gray part represents inferior nodes, and the white part represents natural nodes. In (a), the parent node is node 4, and the current node is node x. When considering the neighboring nodes of node x, only node 5 needs to be considered, while other nodes are not considered. Similarly, in (b), the parent node is node 6, and the current node is node x. When considering the neighboring nodes of node x, only nodes 2, 3, and 5 need to be considered, while other nodes are not considered.

Figure 3 shows the situation of reaching the current node from the parent node in a grid map when there are obstacles in the map, divided into straight and diagonal cases. At this time, in (a), node 2 is occupied by an obstacle, and node 3 changes from an inferior node to a forced neighbor of node x. In (b), node 4 is occupied by an obstacle, and node 1 changes from an inferior node to a forced neighbor of node x. It can also be seen from the figure that forced neighbors evolve from inferior nodes.

A node can become a jump point when it satisfies one of the following three conditions:

• Node x is the start or end point.
• Node x has at least one forced neighbor.
• The parent node p of node x is in the diagonal direction, and there exists a node in the straight direction (horizontal or vertical) of node x that satisfies condition one or two.

3.2.2. Map Construction

For front-end path search, this paper designs three environments with different difficulty levels based on different obstacle densities: simple environment, medium-complexity environment, and complex environment. Before conducting route planning, it is also necessary to expand the boundaries of obstacles outward to ensure that during actual navigation, the UAV will not impact obstacles, thereby improving the safety and robustness of planning [37]. This is because the drone has certain physical dimensions, and obstacle inflation can keep a buffer zone between the drone and obstacles [38], while also compensating for sensor perception errors to a certain extent, providing a buffer zone to cope with these uncertainties. The obstacle parameters in the three environments are shown in

Table 1. Simple environment obstacle parameters.

Obstacle	Map1		Map2
	Lower-Left	Upper-Right	Lower-Left	Upper-Right
1	(1, 0.5, 0.1)	(2, 0.7, 3)	(2.25, 0, 0)	(2.65, 1.9, 3.4)
2	(0, 1.5, 0)	(1, 1.7, 3)	(0.05, 1.1, 0)	(0.45, 3, 3.4)
3	(2, 1.5, 0.1)	(3, 1.7, 3)	(4.5, 1.1, 0)	(4.9, 3, 3.4)

,

Table 2. Medium-complexity environment obstacle parameters.

Obstacle	Map3		Map4
	Lower-Left	Upper-Right	Lower-Left	Upper-Right
1	(0, 2, 0)	(10, 2.5, 1.5)	(3.1, 0, 2.1)	(3.9, 5, 6)
2	(0, 2, 4.5)	(10, 2.5, 6)	(9.1, 0, 2.1)	(9.9, 5, 6)
3	(0, 2, 1.5)	(3, 2.5, 4.5)	(15.1, 0, 2.1)	(15.9, 5, 6)
4	(7, 2, 1.5)	(10, 2.5, 4.5)	(0.1, 0, 0)	(0.9, 5, 3.9)
5	(3, 0, 2.4)	(7, 0.5, 4.5)	(6.1, 0, 0)	(6.9, 5, 3.9)
6	(0, 15, 0)	(0, 10, 20)	(12.1, 0, 0)	(12.9, 5, 3.9)
7	(0, 15, 1)	(1, 10, 16)	(18.1, 0, 0)	(18.9, 5, 3.9)
8	(0, 18, 4.5)	(10, 19, 6)	—	—

and

Table 3. Complex environment obstacle parameters.

Obstacle	Map5		Map6
	Lower-Left	Upper-Right	Lower-Left	Upper-Right
1	(0, −5, 0)	(10, 20, 6)	(0, 4, 0)	(1, 10, 10)
2	(0, −2, 3)	(10, −1.5, 6)	(0, 0, 0)	(3, 3, 10)
3	(0, −2, 1.5)	(3, −1.5, 3)	(2, 0, 0)	(3, 8, 10)
4	(6, −2, 1.5)	(10, −1.5, 3)	(4.5, 6, 0)	(5.5, 10, 10)
5	(0, 2, 0)	(10, 2.5, 1.5)	(4.5, 4, 0)	(5.5, 6, 3.5)
6	(0, 2, 4.5)	(10, 2.5, 6)	(4.5, 4, 6.5)	(5.5, 6, 10)
7	(0, 7, 0)	(10, 7.5, 0.5)	(4.5, 0, 0)	(5.5, 4, 10)
8	(0, 7, 2)	(10, 7.5, 5.5)	(6, 0, 0)	(7, 10, 2)
9	(0, 11, 0)	(10, 11.5, 2.5)	(6, 8.5, 2)	(7, 10, 8)
10	(0, 11, 4)	(10, 11.5, 5.5)	(6, 4, 2)	(7, 7.5, 8)
11	(0, −2, 0)	(0, 10, −1.5)	(6, 0, 2)	(7, 2, 8)
12	(0, −2, 3)	(10, −1.5, 5.5)	(6, 0, 8)	(7, 10, 10)
13	(0, 2, 1.5)	(3, 2.5, 4.5)	(8.5, 5, 0)	(9.5, 9, 10)
14	(7, 2, 1.5)	(10, 2.5, 4.5)	(8.5, 1.5, 0)	(11, 3.5, 10)
15	(3, 0, 2.4)	(7, 0.5, 4.5)	(8.5, 0, 0)	(13, 0.5, 10)
16	(0, 15, 0)	(10, 20, 1)	(10.5, 3.5, 0)	(11, 10, 10)
17	(0, 15, 1)	(10, 16, 3.5)	(11, 3, 0)	(13, 10, 10)
18	(0, 18, 4.5)	(10, 19, 6)	(11.5, 0.5, 0)	(13, 2, 10)

. The tables only list the lower-left and upper-right corner coordinates of each cuboid obstacle. Since the front-end map will be gridded, the most regular cuboids are chosen to represent obstacles, and any other shape can similarly simulate obstacles. The obstacle density increases in the three environments, and the planning difficulty increases accordingly.

Figure 4, Figure 5 and Figure 6 show the obstacle distributions in six different scenarios. The inner cuboids represent the actual obstacles, and the outer cuboids are the expanded obstacles.

In Figure 4, the obstacle distribution in the simple environment can simulate open areas in real environments relatively simply. The error tolerance for drone flight trajectories is large, and accidents are less likely to occur.

In Figure 5, the obstacle distribution in the medium-complexity environment is relatively concentrated, requiring higher standards for drone flight trajectories. The planning difficulty increases accordingly, and the drone’s kinodynamic requirements are higher.

In Figure 6, the obstacle distribution in the complex environment is concentrated with high density to simulate crowded areas in real environments. At this time, the error tolerance for drone flight trajectories is small, and it is easy to collide with obstacles due to different factors. Therefore, the requirements for flight trajectories also increase accordingly, and the planning difficulty increases.

3.2.3. JPS–Bresenham-Based Path Search

The key innovation of JPS–Bresenham over standard JPS [36] lies in the post-processing waypoint reduction mechanism. Standard JPS generates jump points by identifying forced neighbors and straight-line expansions, which significantly reduces the number of expanded nodes compared to A* but still produces waypoint sequences with many collinear intermediate points. These redundant waypoints increase the complexity of downstream corridor construction and trajectory optimization. Our JPS–Bresenham integration addresses this limitation by applying Bresenham-based line-of-sight checking as a post-processing step, which removes all intermediate waypoints lying on the same straight line while preserving collision-free constraints. This integration is theoretically grounded with provable bounds on waypoint reduction and maintains path optimality.

Bresenham is a classic algorithm in the field of computer graphics [39], used to draw lines determined by two points. The key to the Bresenham algorithm is tracking the deviation between the ideal position of the line and the actual grid position, i.e., the error term. The algorithm starts from the starting point and decides whether to move in the x or y direction for the next step. By calculating the error term to adjust the step size increment, the next grid cell closest to the ideal line is selected. As shown in Figure 7, starting from the starting point, the algorithm calculates the intersection of the line with the vertical grid line and the distance error term from the grid point to the intersection. Then, based on the sign of the distance error term, it determines the grid cell in the grid closest to the intersection and uses it as a grid representing the line.

When the absolute value of the line slope is less than 1, iterate along the x-axis direction; when the absolute value is greater than 1, iterate along the y-axis direction. The algorithm steps for iterating along the x-axis direction and along the y-axis direction differ only in sign. This paper uses iteration along the x-axis direction as an example for analysis; iteration along the y-axis direction follows the same logic.

Let the starting point coordinates be $(x_1,y_1)$, the end point coordinates be $(x_2,y_2)$, the line equation be $y=kx+b$, and the slope calculation formula be $k={\displaystyle \frac{\Delta y}{\Delta x}}=(y_2-y_1)/(x_2-x_1)$. Let the current grid map coordinates be $(x_i,y_i)$. The next grid map coordinates are chosen between $(x_i+1,y_i)$ and $(x_i+1,y_i+1)$. First, calculate the intersection coordinates $(x_i+1,{\widehat{y}}_{i+1})$. The calculation formula is

$$x_{i+1}=x_i,{\widehat{y}}_{i+1}=k\left(x_i+1\right)+b$$

(1)

Then calculate the distance error terms $d_{upper}$ and $d_{lower}$ between the two candidate points and the intersection:

$$d_{upper}=y_i+1-{\widehat{y}}_{i+1}=y_i+1-k{x}_{i+1}-b$$

(2)

$$d_{lower}={\widehat{y}}_{i+1}-y_i=k{x}_{i+1}+b-y_i$$

(3)

By comparing the magnitudes of $d_{upper}$ and $d_{lower}$, determine which point to select.

The Bresenham algorithm is integrated into the JPS framework as a post-processing step rather than being embedded within the jump point search itself. This two-stage approach consists of (1) a JPS stage, where standard JPS identifies jump points and generates a collision-free path, and (2) a Bresenham Stage, where for each consecutive pair of waypoints $(p_i,p_{i+1},\dots ,p_j)$ from the JPS output, Bresenham line-of-sight checking tests whether intermediate waypoints can be safely removed. If the line segment from $p_i$ to $p_j$ is collision-free, all intermediate waypoints are discarded. This decoupled design maintains the efficiency of JPS while achieving aggressive waypoint reduction.

Consider a simple 2D grid map with start position $(0,0)$ and goal position $(5,3)$. Standard JPS might generate the waypoint sequence $(0,0)\to (1,0)\to (2,0)\to (3,1)\to (4,2)\to (5,3)$, totaling 6 waypoints. The JPS–Bresenham algorithm applies Bresenham line-of-sight checking to consecutive waypoints: testing $(0,0)$ to $(2,0)$ confirms a clear line-of-sight, removing $(1,0)$; testing $(0,0)$ to $(3,1)$ reveals an obstacle, thus keeping $(2,0)$. This process continues, ultimately producing the simplified sequence $(0,0)\to (2,0)\to (5,3)$, with only 3 waypoints while maintaining the same collision-free path. This example demonstrates how Bresenham post-processing eliminates redundant collinear waypoints, reducing the waypoint count by 50% in this case.

3.2.4. Theoretical Analysis of Waypoint Reduction

To theoretically justify the effectiveness of the JPS–Bresenham method, we analyze the expected number of waypoints after Bresenham post-processing. Let $N_{\mathrm{JPS}}$ be the number of waypoints generated by standard JPS, and $N_{\mathrm{JB}}$ be the number after Bresenham simplification. For a grid-based path with K direction changes, the Bresenham algorithm removes all intermediate waypoints between direction change points, yielding

$$N_{\mathrm{JB}}=K+2\le N_{\mathrm{JPS}}$$

(4)

where $K\ll N_{\mathrm{JPS}}$ in cluttered environments. This guarantees that the simplified path maintains collision-free constraints while significantly reducing computational burden for downstream optimization.

Let N be the number of grid cells and M be the number of obstacles in the map. Standard JPS has time complexity $O(NlogN)$ in the worst case, with space complexity $O\left(N\right)$ for the priority queue and visited set. The Bresenham post-processing step adds $O(W·D)$ time complexity, where W is the number of waypoints from JPS and D is the maximum number of grid cells along any straight-line segment between waypoints. In practice, $W\ll N$ and $D\ll N$, making the Bresenham step computationally negligible. The overall time complexity of JPS–Bresenham remains $O(NlogN)$, with no increase in asymptotic complexity compared to standard JPS. However, the waypoint reduction achieved by Bresenham (from W to $K+2$ where K is the number of direction changes) directly reduces the complexity of downstream corridor construction from $O(W·M)$ to $O\left(\right(K+2)·M)$, yielding significant overall computational savings.

This study employs the Bresenham algorithm for obstacle detection. That is, if there are no obstacles and normal passage between the parent node of the current node and the neighboring domain node, then the current node is directly discarded, and the parent node of the current node is directly connected to the neighboring domain node. This results in straighter and more direct paths, avoiding multiple waypoints piling up together and affecting subsequent data processing. After planning a feasible path through JPS, the Bresenham algorithm is used for collision detection to remove redundant nodes and keep only key nodes, reducing the burden on back-end optimization. A detailed implementation procedure of the algorithm is presented in Algorithm 1.

In the JPS–Bresenham algorithm, a priority queue is used to store all nodes to be expanded. The heuristic function $h\left(n\right)$ for all nodes is predefined as the Manhattan distance. After initialization, the priority queue contains only the starting node, with $g\left(X_s\right)=0$ for the starting node and $g\left(n\right)=\infty$ for other nodes. Lines 1–4 indicate that if the priority queue is empty, the algorithm ends with no feasible solution found. Lines 5–6 indicate marking the node with the smallest f value as expanded. Lines 7–10 indicate that the target node is found, and the algorithm ends. Lines 11–19 indicate expanding neighbor nodes m of node n. At this time, neighbor nodes do not mean physically adjacent nodes but jump points. Lines 12–15 indicate that if neighbor node m has not been expanded, we should add it to the priority queue. Lines 16–18 indicate that if neighbor node m has been expanded and reaching m through current node n is better, we should update the value of $g\left(m\right)$.

The waypoint reduction achieved by JPS–Bresenham directly benefits the downstream trajectory optimization in two critical ways. First, fewer waypoints reduce the number of safe flight corridors that need to be constructed, decreasing the computational complexity of ellipsoid fitting from $O(W·M)$ to $O\left(\right(K+2)·M)$, where K is the number of direction changes. Second, with fewer corridors, the Bézier curve optimization problem has fewer control points to optimize, reducing the size of the quadratic programming problem and enabling faster solution times. This tight integration between front-end path search and back-end optimization is a key advantage of our hierarchical framework.

Algorithm 1 JPS–Bresenham Algorithm

Input: 3D grid map $\mathcal{M}$, start position ${\mathbf{p}}_{\mathrm{start}}$, goal position ${\mathbf{p}}_{\mathrm{goal}}$ Output: Simplified waypoint sequence $\{{\mathbf{p}}_0,{\mathbf{p}}_1,\dots ,{\mathbf{p}}_n\}$   1: if sequence is empty then   2:     return False; break;   3: end if   4: Assign the first point in the sequence to the initial node point of the waypoint list as node “n” and mark it as “has passed”;   5: Mark node “n” as “passed”;   6: if node “n” is the target node then   7:     return True; break;   8: end if   9: for all neighbor nodes “m” of node “n” do 10:     if $g\left(m\right)=\infty$ then 11:         $g\left(m\right)=g\left(n\right)+C_{nm}$; Add “m” to the queue; 12:     end if 13:     if $g\left(m\right)>g\left(n\right)+C_{nm}$ then 14:         $g\left(m\right)=g\left(n\right)+C_{nm}$; 15:     end if 16: end for 17: // Bresenham 18: for JPS corresponding waypoint sequence do 19:     if the current node and the next node are not on the same line and both are not obstacle nodes then 20:         Keep the current node; 21:     end if 22: end for

3.3. Convex Space Construction

In this section, using the geometric path provided by the front-end JPS–Bresenham path search method from the previous section, convex polyhedra are constructed to convexly decompose the free space into safe flight corridors, and the trajectory is strictly constrained within the flight corridors. Then the boundary planes of the polyhedra are added as hard constraints to the following trajectory refinement problem to ensure safe flight of the quadrotor.

3.3.1. Safe Corridor Construction

The key algorithmic novelty of our safe corridor construction lies in two aspects. First, we introduce a bounding box pre-filtering mechanism that reduces the obstacle search space by an average of 53.2% compared to standard ellipsoid fitting methods. Second, we derive the stopping condition for ellipsoid inflation based on the distance gradient, which guarantees convergence to a locally maximal ellipsoid within finite iterations.

The set of obstacles in the free space is denoted as O. The piecewise linear path P from the start point to the target point is represented as $P=〈p_0\to p_1\to \dots \to p_n〉$, where $p_i$ is a point in the free space, and $p_i\to p_{i+1}$ is a directed line segment in the free space. A convex polyhedron is generated around each segment in P to construct a valid SFC. The i-th segment is represented as $L_i=〈p_i\to p_{i+1}〉$, and the convex polyhedron generated by each $L_i$ is represented as $c_i$. The set of convex polyhedra is represented as

$$SFC\left(P\right)=\left\{c_i|i=0,1,\dots ,n-1\right\}$$

(5)

When constructing safe flight corridors, two consecutive polyhedra $c_i$ and $c_{i+1}$ need to intersect in a non-empty subset containing $p_{i+1}$ to ensure trajectory continuity. Constructing safe corridors requires the following steps:

(1) Fitting an ellipsoid based on directed line segments: Find an ellipsoid containing segment L that does not contain points from the obstacle set O. The ellipsoid is represented as

$$\zeta (E,d)=\left\{p=E\overline{p}+d|∥\overline{p}∥\le 1\right\}$$

(6)

E is a $3\times 3$ symmetric positive definite matrix representing the deformation of a sphere ($∥\overline{p}∥\le 1$). $E=R^{T}SR$, where R is the rotation matrix from the map coordinate system to the ellipse coordinate system, the diagonal matrix $S=\mathrm{diag}(a,b,c)$, with diagonal elements representing the corresponding lengths of the ellipsoid semi-axes, $a\ge b,a\ge c$, and d represents the center of the ellipsoid. Then, based on the given segment L and obstacle set O, obtain the symmetric positive definite matrix E and ellipsoid center d.

The ellipsoid calculation is divided into two steps: The first step is to first form a sphere with radius equal to half the path length; the center of the sphere is the midpoint of the path, and the length of the sphere’s x-axis is fixed and aligned with L. Then find the obstacle closest to the center contained within the sphere, shrink the y-axis, and repeat this process until the ellipsoid contains no obstacles. The second step stretches the z-axis of the ellipsoid to obtain the maximum ellipsoid [21]. The obstacle point in contact with the maximum ellipsoid is denoted as $p^{*}$.

(2) Constructing convex polyhedra: Represent the ellipsoid found in the first step as ${\zeta }_0$, with the contacting obstacle point $p_0^c=p^{*}$. At this time, using this point as a tangent point, form a half-plane tangent to the ellipsoid, creating a half-space $H_0=\left\{p|a_0^{T}p<b_0\right\}$ containing the ellipsoid. After calculating $H_0$, remove all obstacle points outside the half-space from the obstacle set O, then inflate the ellipsoid until it contacts another obstacle point $p_1^c$, forming a new ellipsoid ${\zeta }_1$, forming a new half-plane creating a new half-space $H_1$. Continue this process until the obstacle set O is completely removed. At this point, obtain a set of half-spaces $\left\{H_0,H_1,\dots ,H_m\right\}$. The intersection of these $m+1$ half-spaces forms a convex polyhedron, represented as

$$C=\bigcap _{j=0}^m{H}_j=\left\{p\in {\mathbb{R}}^3|{\mathbf{a}}_j^T\mathbf{p}\le b_j,j=0,1,\dots ,m\right\}$$

(7)

In each iteration process, the j-th half-space $H_j$ is tangent to ellipsoid ${\zeta }_j$ at point $p_j^c$. The parameters ${\mathbf{a}}_j$ and $b_j$ define the half-space as $H_j=\{\mathbf{p}\in {\mathbb{R}}^3\mid {\mathbf{a}}_j^T\mathbf{p}\le b_j\}$. Geometrically, ${\mathbf{a}}_j$ is the outward normal vector to the ellipsoid at the contact point $p_j^c$, pointing away from the ellipsoid center, while $b_j$ determines the offset of the tangent plane from the origin. These parameters are calculated from the ellipsoid’s gradient at the contact point:

$${\mathbf{a}}_j={\left.{\displaystyle \frac{d{\xi }_r}{d\mathbf{p}}}\right|}_{\mathbf{p}={\mathbf{p}}_j^c}=2{\mathbf{E}}^{-1}{\mathbf{E}}^{-T}({\mathbf{p}}_j^c-\mathbf{d})$$

(8)

$$b_j={\mathbf{a}}_j^T{\mathbf{p}}_j^c$$

(9)

where ${\mathbf{a}}_j$ represents the normal vector of the j-th half-space plane, and $b_j$ represents the corresponding offset parameter. The collection ${\{{\mathbf{a}}_j,b_j\}}_{j=0}^m$ fully specifies the convex polyhedron as the intersection of $m+1$ half-spaces.

Using this method for each segment obtained from the front-end search, the final safe flight corridor $SFC\left(P\right)=\left\{c_i|i=0,1,\dots ,n-1\right\}$ in the free space is obtained.

When constructing polyhedra for each segment, it is necessary to search all points in the obstacle set O at least twice to check for intersections between obstacles and the inflated ellipsoid, which is very computationally expensive [40]. Therefore, a bounding box is added for each segment to reduce the number of obstacle points that need to be checked. Each time the ellipsoid inflates and intersects with obstacles, only the obstacle points within the bounding box need to be checked. This not only reduces the number of obstacle points that need to be checked, improving algorithm efficiency, but also prevents the inflated ellipsoid from deviating too far from the segment, causing the trajectory to deviate too far from the original path.

3.3.2. Time Allocation

A trajectory is a time-parameterized path. Therefore, when performing back-end optimization, appropriate time must be allocated to each trajectory segment to enable solving. Allocating appropriate time to trajectories is a critical issue in the planning process, as it directly affects the quality of planning results. When waypoints are evenly distributed, the same time can be assigned to each path segment, or time can be allocated based on the Euclidean distance between waypoints, which is simple and effective. However, in practical applications, unreasonable time allocation can produce deformed trajectories that are unfavorable for drone execution [41]. This section uses trapezoidal velocity planning to calculate the time required for each trajectory segment. The trapezoidal velocity profile consists of three phases: acceleration, constant velocity, and deceleration. By defining maximum acceleration limit $a_{max}$ and maximum velocity limit $v_{max}$, we can derive the time allocation for each segment. The key idea is to equate the segment length with the total displacement calculated from the velocity profile. The trapezoidal velocity curve is divided into three parts. The first part has constant acceleration, velocity is a linear function of time, and displacement is a parabolic function of time. The second part has zero acceleration and constant velocity, and displacement is a linear function of time. The third part has constant negative acceleration, velocity decreases linearly, and displacement is a quadratic polynomial of time. Generally, it is assumed that acceleration and deceleration times are equal.

In the uniform acceleration phase:

$$s\left(t\right)={\displaystyle \frac{1}{2}}{a}_{max}{t}^2,0\le t\le T_a,\mathrm{where}{T}_a={\displaystyle \frac{v_{max}}{a_{max}}}$$

(10)

In the uniform velocity phase:

$$s\left(t\right)=v_{max}t-{\displaystyle \frac{v_{max}^2}{2a_{max}}},T_a\le t\le T-T_a$$

(11)

In the uniform deceleration phase:

$$s\left(t\right)={\displaystyle \frac{2a_{max}{v}_{max}T-2v_{max}^2-a_{max}^2{(t-T)}^2}{2a_{max}}},T-T_a\le t\le T$$

(12)

Therefore, given that the linear distance of the i-th path segment is $x_i$, the allocated time is as follows:

To derive the time allocation formula, we consider the complete trapezoidal profile. The total displacement $x_i$ consists of three components: acceleration phase displacement $s_a={\displaystyle \frac{1}{2}}{a}_{max}{T}_a^2$, constant velocity phase displacement $s_c=v_{max}(T_i-2T_a)$, and deceleration phase displacement $s_d=v_{max}{T}_a-{\displaystyle \frac{1}{2}}{a}_{max}{T}_a^2$. Summing these and solving for $T_i$ yields

$$T_i={\displaystyle \frac{x_i}{v_m}}-{\displaystyle \frac{v_m}{{\mathrm{acc}}_m}}$$

(13)

This section defines total distance $s=30$, total time $T=4$, acceleration and deceleration time $T_a=T_d=1$, and $v_{max}=10$. Figure 8 shows the position, velocity, and acceleration variation curves in the uniform acceleration phase, uniform velocity phase, and uniform deceleration phase.

3.4. Bézier Curve-Based Back-End Trajectory Optimization

In front-end path planning, JPS–Bresenham is used to search for feasible geometric paths in discrete grid maps. Based on the path segments, ellipsoids are first fitted, then convex safe corridors are constructed, obtaining a safe flight corridor area from the starting point to the target point. Since the ellipsoids are inside the corresponding polyhedra, each segment is also inside the polyhedra, ensuring that the entire path is inside the safe flight corridor.

Traditional piecewise polynomials are inconvenient for adding global safety and kinodynamic feasibility constraints [42]. Constraints can only be imposed on several points of the trajectory. After calculating the trajectory, the extrema of the trajectory are solved to determine whether safety and kinodynamic feasibility constraints are violated. Multiple iterations are required to solve for an appropriate trajectory or detect infeasibility [43]. This is undoubtedly unreliable for drones with high real-time requirements. This section adopts Bézier curves instead of traditional piecewise polynomials to represent trajectories. Only corresponding safety and kinodynamic feasibility constraints need to be imposed on control points, which can effectively reduce algorithm complexity.

3.4.1. Bézier Curves

Bézier curves are defined by a set of control points, with the equation

$$B_j\left(t\right)=c_j^0{b}_n^0\left(t\right)+c_j^1{b}_n^1\left(t\right)+\cdots +c_j^n{b}_n^n\left(t\right)=\sum _{i=0}^n{c}_j^i{b}_n^i\left(t\right)$$

(14)

$$b_n^i\left(t\right)=\left({\displaystyle \genfrac{}{}{0pt}{}{n}{i}}\right)·t^i·{(1-t)}^{n-i}$$

(15)

where $B_j\left(t\right)$ represents the Bézier curve expression of the j-th trajectory segment, $b_n^i\left(t\right)$ is the Bernstein basis function, n is the polynomial order, and $c_j^i$ represents the coefficient of the i-th basis function of the j-th trajectory segment, called a control point. A Bézier curve is a special polynomial that can be mapped to an ordinary polynomial in a certain way.

Bézier curves have the following properties:

• Endpoint interpolation property: Bézier curves always start at the first control point and end at the last control point, without passing through other control points;
• Convex hull property: Bézier curves are completely constrained within the convex hull formed by their control points;
• Hodograph property: The derivative of a Bézier curve is still a Bézier curve, and the control points of the derivative can be linearly represented by the control points of the original Bézier curve;
• Fixed time interval: Bézier curves are always defined within $[0,1]$.

Due to the convex hull property of Bézier curves, by constraining the control points of the Bézier curve within the safe flight corridor, the Bézier curve must also be within the safe flight corridor. Due to the Hodograph property, high-order physical constraints (velocity, acceleration, jerk, snap) can be conveniently expressed in the form of control points. The fixed time interval property requires time normalization of trajectory parameters.

3.4.2. Linear Constraint Transformation

The critical theoretical contribution is the transformation of non-convex safe corridor constraints into linear inequalities. Given a safe corridor defined by half-spaces $\left\{H_j\right\}$ and a Bézier curve $B\left(t\right)={\sum }_{i=0}^n{c}_i{b}_n^i\left(t\right)$, the convex hull property implies

$$B\left(t\right)\in \bigcap _j{H}_j\iff \{c_0,c_1,\dots ,c_n\}\subset \bigcap _j{H}_j$$

(16)

This transformation converts the continuous constraint satisfaction problem into a finite set of linear constraints on control points, reducing the optimization complexity from non-convex to convex quadratic programming.

3.4.3. Minimum Snap Optimization

A complex trajectory is difficult to represent with a single polynomial. A piecewise approach is used to represent each trajectory segment separately. In the trajectory planning process, position information and high-order information are set at the start and end points, and smoothness is maintained at the connection points of adjacent trajectories (position continuity, high-order kinodynamic continuity). The defined piecewise polynomial function is as follows:

$$f\left(t\right)=\left\{\begin{array}{ccc}{f}_1\left(t\right)\doteq \sum _{i=0}^N{p}_{1,i}{t}^i\hfill & \hfill & T_0\le t\le T_1\hfill \\ f_2\left(t\right)\doteq \sum _{i=0}^N{p}_{2,i}{t}^i\hfill & \hfill & T_1\le t\le T_2\hfill \\ ⋮\hfill & \hfill & ⋮\hfill \\ f_M\left(t\right)\doteq \sum _{i=0}^N{p}_{M,i}{t}^i\hfill & \hfill & T_{M-1}\le t\le T_M\hfill \end{array}\right.$$

(17)

To ensure that the drone can continuously and smoothly pass through each waypoint, position constraints and high-order derivative constraints need to be imposed on each trajectory segment, representing the k-th order derivative of the j-th trajectory segment at time $T_j$:

$$f_j^{\left(k\right)}\left(T_j\right)=x_j^{\left(k\right)}$$

(18)

Expanding $f_j^{\left(k\right)}\left(T_j\right)$ and converting it to matrix form gives

$$\sum _{i\ge k}{\displaystyle \frac{i!}{(i-k)!}}{T}_j^{i-k}{p}_{j,i}=\left[\begin{array}{ccc}\dots & {\displaystyle \frac{i!}{(i-k)!}}{T}_j^{i-k}& \dots \end{array}\right]\left[\begin{array}{c}\hfill ⋮\\ \hfill p_{j,i}\\ \hfill ⋮\end{array}\right]=x_{T,j}^{\left(k\right)}$$

(19)

The position and high-order derivative constraints of the trajectory are represented as

$${\mathbf{A}}_j{\mathbf{p}}_j={\mathbf{d}}_j$$

(20)

To ensure that adjacent trajectory segments are continuous and smooth, physical constraints such as position, velocity, and acceleration at the junction of adjacent trajectories must remain consistent, represented as

$$f_j^{\left(k\right)}\left(T_j\right)=f_{j+1}^{\left(k\right)}\left(T_j\right)$$

(21)

Expanding the above equation and converting it to matrix form gives

$$\sum _{i\ge k}{\displaystyle \frac{i!}{(i-k)!}}{T}_j^{i-k}{p}_{j,i}-\sum _{l\ge k}{\displaystyle \frac{l!}{(l-k)!}}{T}_j^{l-k}{p}_{j+1,l}=0$$

(22)

$$\left[\begin{array}{ccccc}\dots & {\displaystyle \frac{i!}{(i-k)!}}{T}_j^{i-k}& \dots & -{\displaystyle \frac{l!}{(l-k)!}}{T}_j^{l-k}& \dots \end{array}\right]\times \left[\begin{array}{c}⋮\\ p_{j,i}\\ ⋮\\ p_{j+1,l}\\ ⋮\end{array}\right]=0$$

(23)

The continuity constraints of adjacent trajectory segments are represented as

$$\left[\begin{array}{c}\hfill {\mathbf{A}}_j-{\mathbf{A}}_{j+1}\end{array}\right]\left[\begin{array}{c}\hfill {\mathbf{p}}_j\\ \hfill {\mathbf{p}}_{j+1}\end{array}\right]=0$$

(24)

The optimization objective of Minimum Snap is to minimize the second derivative of acceleration, which physically represents minimizing the change in lift to save energy. Therefore, this optimization problem can be transformed into a constrained quadratic programming problem. The objective function is as follows:

$$min{f}^{\left(4\right)}\left(t\right)=min{\left[\begin{array}{c}\hfill {\mathbf{p}}_1\\ \hfill ⋮\\ \hfill {\mathbf{p}}_M\end{array}\right]}^T\left[\begin{array}{ccc}{\mathbf{Q}}_1& \mathbf{0}& \mathbf{0}\\ \mathbf{0}& \ddots & \mathbf{0}\\ \mathbf{0}& \mathbf{0}& {\mathbf{Q}}_M\end{array}\right]\left[\begin{array}{c}\hfill {\mathbf{p}}_1\\ \hfill ⋮\\ \hfill {\mathbf{p}}_M\end{array}\right]$$

(25)

$$\mathrm{s}.\mathrm{t}.{\mathbf{A}}_{eq}\left[\begin{array}{c}\hfill {\mathbf{p}}_1\\ \hfill ⋮\\ \hfill {\mathbf{p}}_M\end{array}\right]={\mathbf{d}}_{eq}$$

(26)

The equality constraints include position and high-order derivative constraints, as well as continuity constraints between adjacent trajectories. By optimizing the quadratic formulation problem, the parameters of each path segment can be obtained, which describes position as a function of time.

4. Experiments

4.1. Experimental Setup and Dataset

All experiments are conducted on a computational platform equipped with a 12th Gen Intel(R) Core(TM) i5-12400 processor @ 2.5 GHz and 32 GB RAM, running Windows 11 Home operating system. The implementation utilizes MATLAB R2023a for algorithm development, integration and visualization. To thoroughly assess the effectiveness of the presented framework, we have constructed six benchmark scenarios with varying obstacle densities and environmental complexities. These environments are designed to simulate realistic operational conditions for quadrotor navigation, ranging from open spaces with sparse obstacles to highly cluttered indoor-like environments. Each scenario is tested with multiple start-goal configurations to assess the algorithm’s robustness and consistency across different planning queries.

The current implementation achieves average trajectory generation times of 0.34–0.44 s on a desktop platform (i5-12400, 32GB RAM). For deployment on typical UAV onboard computers such as NVIDIA Jetson Xavier NX, which offer approximately 15–20% of the testing platform’s computational capability, our method’s modular architecture provides clear optimization pathways. The JPS–Bresenham front-end search can be compiled to efficient C++ implementations suitable for ARM architectures, while ellipsoid fitting computations can leverage GPU acceleration available on modern onboard computers. These optimizations enable computational efficiency suitable for real-time trajectory planning on embedded systems. For time-critical replanning scenarios in dynamic environments, incremental strategies that reuse corridor information from previous cycles can significantly reduce computation time, making our approach viable for online operations where rapid response to environmental changes is required.

4.2. Performance Evaluation Metrics

We evaluate our approach using several quantitative metrics that capture different aspects of planning performance:

• Path Length: The cumulative straight-line distance spanning from start to goal along the planned path.
• Computation Time: Total time including initial path exploration, corridor construction, and trajectory refinement.
• Number of Waypoints: Total waypoints in the geometric path, indicating path complexity.
• Snap Integral: The cumulative sum of snap squared (position’s 4th-order derivative), measuring trajectory smoothness.
• Maximum Velocity/Acceleration: Peak values of trajectory derivatives, verifying kinodynamic feasibility.

4.3. Front-End Path Planning Experiments

To validate the performance of the JPS–Bresenham front-end path search method, this section conducts path planning simulation experiments using JPS–Bresenham, JPS algorithm [44], RRT* algorithm [45], and PRM algorithm [46] in different scenarios. As shown in Figure 9, Figure 10, Figure 11, Figure 12, Figure 13 and Figure 14, the experimental results record the final planned paths of different algorithms in different maps. For ease of visualization, only the top view of the final planning results is shown.

JPS effectively reduces computation by skipping unnecessary nodes, accelerating path search speed. RRT* samples throughout the entire space, especially in high-dimensional spaces requiring substantial computing resources, has randomness, and is probabilistically complete, but often not optimal, with longer algorithm running time; PRM requires more computing resources in the early sampling and graph construction stages, but later does not need to search the entire space, only searching on the constructed graph; it is probabilistically complete, but PRM is time-consuming when checking collisions and may be less efficient in complex environments. From the figures, it can be seen that the paths generated by RRT* and PRM are relatively rough with strong randomness. They can find optimal solutions only when there is sufficient time.

Figure 9 shows path planning results in the simple environment (Map1) with sparse obstacle distribution. All four methods successfully find collision-free paths from start to goal. Visually, the JPS and JPS–Bresenham paths appear nearly identical and highly direct, reflecting the grid-based nature of these algorithms. In contrast, the RRT* and PRM paths exhibit more curvature and detours, characteristic of their sampling-based approach. As quantified in

Table 4. Performance comparison of different algorithms for path planning.

Map	Algorithm	Path Length	Waypoints	Time (s)
Map1	JPS [44]	3.7276	13	0.13
	RRT* [45]	5.5098	6	4.82
	PRM [46]	5.2365	7	3.37
	JPS–Bresenham	3.4859	8	0.15
Map2	JPS	14.6572	26	0.21
	RRT*	14.9452	9	5.24
	PRM	16.9338	6	4.56
	JPS–Bresenham	14.2825	8	0.24
Map3	JPS	23.0685	25	0.64
	RRT*	23.3988	8	4.89
	PRM	27.2583	6	5.02
	JPS–Bresenham	22.6777	6	0.28
Map4	JPS	27.1576	47	0.82
	RRT*	28.2183	13	7.20
	PRM	32.1264	14	5.59
	JPS–Bresenham	25.8701	13	0.91
Map5	JPS	24.4271	32	0.61
	RRT*	24.8791	9	4.21
	PRM	25.8316	9	4.55
	JPS–Bresenham	23.3693	14	0.68
Map6	JPS	19.0359	39	0.37
	RRT*	18.8136	9	5.68
	PRM	19.1350	9	4.86
	JPS–Bresenham	18.4513	18	0.45

, JPS–Bresenham achieves the shortest path length (3.49 m) and reduces waypoints by 38% compared to standard JPS, demonstrating effective redundancy elimination along straight-line segments in open environments.

Figure 11 presents results for the medium-complexity environment (Map3) with concentrated obstacles. The increased obstacle density creates more constrained navigation scenarios. Visual inspection reveals that while all methods avoid obstacles, the JPS–Bresenham path maintains better directness with fewer direction changes compared to standard JPS. According to Table 4, JPS–Bresenham achieves a 1.7% path length reduction (22.68 m vs. 23.07 m for JPS) and a substantial 76% waypoint reduction (6 vs. 25 waypoints). The RRT* and PRM paths show significant deviation from optimal routes, with path lengths 1–18% longer than JPS–Bresenham, confirming that sampling-based methods struggle to find efficient paths in cluttered environments despite requiring 7–8 times more computation time.

Figure 13 displays results for the complex environment (Map5) with high-density obstacles and narrow passages. This challenging scenario tests the robustness of different planning approaches. All methods successfully navigate through the cluttered environment, but with notably different path characteristics. The JPS–Bresenham path appears more streamlined with fewer sharp turns compared to standard JPS. Table 4 shows that JPS–Bresenham achieves a 4.3% path length reduction (23.37 m vs. 24.43 m for JPS) and a 56% waypoint reduction (14 vs. 32 waypoints). The sampling-based methods (RRT* and PRM) produce paths 2–6% longer than JPS–Bresenham, with computation times exceeding 4 s, making them unsuitable for time-critical logistics applications.

To evaluate the performance improvement of the JPS–Bresenham front-end path search method compared to the JPS search algorithm, this section counts the route distance and the quantity of waypoints on the corresponding path. Regarding route distance, since both RRT* and PRM algorithms need to randomly sample in the map space, resulting in random sampling points, the path lengths of both in the six maps will be longer than JPS and JPS–Bresenham. Because the Bresenham algorithm removes redundant points on the path, allowing key waypoints to be directly connected, the route distance generated by JPS–Bresenham is shorter than that planned by JPS. Regarding the quantity of waypoints, after introducing the Bresenham algorithm, JPS–Bresenham further reduces the number of waypoints, with waypoints significantly reduced compared to JPS. Compared with RRT* and PRM, JPS–Bresenham shows no obvious relationship in the number of waypoints. In terms of running time, both RRT* and PRM generally have high running times and are not suitable for drones with strict time constraints. Since JPS–Bresenham has one additional step compared to JPS, the computation time rises slightly, but the impact is not significant. The experimental findings are presented in Table 4.

The comprehensive experimental results demonstrate the effectiveness of each component in our hierarchical planning framework. In the front-end path search phase, JPS–Bresenham consistently outperforms baseline methods across all six benchmark scenarios. As shown in Table 4, our approach achieves 4–10% shorter paths compared to JPS while reducing computation time by up to 83% compared to sampling-based methods like RRT* and PRM. The Bresenham-based collision detection effectively eliminates redundant waypoints, reducing the average number of waypoints by 52% compared to standard JPS while maintaining path optimality.

4.4. Monte Carlo Statistical Experiments

To further validate the robustness of the proposed JPS–Bresenham method under varying environmental complexities, this section conducts Monte Carlo statistical experiments on randomly generated maps. The previous experiments compared different categories of path planning algorithms (grid-based vs. sampling-based) on fixed maps. This section focuses on comparing grid-based algorithms (A*, JPS, JPS–Bresenham) to quantify the performance improvement brought by the JPS–Bresenham method through statistical analysis across different map sizes and obstacle densities.

The Monte Carlo experiments are conducted under six configurations, each combining two dimensions: map size and obstacle density. Map sizes are categorized into Small ($10\times 10\times 3$ m), Medium ($20\times 20\times 4$ m), and Large ($40\times 40\times 5$ m). Obstacle densities are set at 10% (Low) and 30% (High). For each configuration, 50 independent trials are executed. In each trial, a map is randomly generated with axis-aligned cuboid obstacles uniformly distributed within the boundary. Start and goal positions are randomly sampled, ensuring both are collision-free and their Euclidean distance exceeds 30% of the map’s horizontal dimension to avoid trivial cases. The random seed is fixed to ensure reproducibility.

The implementation directly constructs the occupancy grid map by setting the boundary, resolution, and obstacle block properties of the GridMap class, bypassing file I/O to enable efficient batch generation of random maps. For each trial, A*, JPS, and JPS–Bresenham are sequentially invoked to plan paths from the same start–goal pair, recording the path length, number of waypoints, and computation time. Failed trials (e.g., no path found) are excluded from statistical analysis. The mean values across 50 trials are reported in

Table 5. Monte Carlo statistical results (mean of 50 trials).

Config	Algorithm	Path Length (m)	Waypoints	Time (s)
Small–Low	A*	9.05	49.3	0.270
	JPS	7.82	10.4	0.046
	JPS–Bresenham	7.39	3.4	0.046
Small–High	A*	7.60	42.0	0.150
	JPS	7.27	15.9	0.037
	JPS–Bresenham	6.94	7.1	0.036
Medium–Low	A*	18.27	95.4	6.001
	JPS	17.39	21.4	0.303
	JPS–Bresenham	16.64	8.1	0.303
Medium–High	A*	14.76	77.8	2.222
	JPS	13.37	23.9	0.067
	JPS–Bresenham	12.58	8.6	0.066
Large–Low	A*	35.21	180.1	113.939
	JPS	34.35	42.8	2.117
	JPS–Bresenham	31.96	10.7	2.113
Large–High	A*	31.39	161.0	73.639
	JPS	32.22	53.0	0.383
	JPS–Bresenham	30.87	16.9	0.380

.

Table 5 demonstrates that JPS–Bresenham consistently achieves the shortest path length across all six configurations, with an average reduction of 5.6% compared to JPS and 18.3% compared to A*. This validates the effectiveness of the Bresenham-based post-processing in removing redundant path segments while maintaining collision-free constraints.

The most significant advantage lies in waypoint reduction. JPS–Bresenham decreases the number of waypoints by 67.3% on average relative to JPS, and by 92.1% relative to A*. In Large–High scenarios, JPS–Bresenham produces 16.9 waypoints on average, whereas A* yields 161.0 waypoints—nearly an order of magnitude difference. Fewer waypoints reduce the complexity of downstream trajectory optimization, directly lowering computational burden for the back-end planner.

Regarding computation time, JPS and JPS–Bresenham maintain consistent efficiency, with the additional Bresenham step introducing negligible overhead (under 0.01 s across all configurations). A* exhibits acceptable performance on Small maps but suffers from exponential growth in search space as map size increases, reaching 113.939 s on Large–Low maps—over 50 times slower than JPS-based methods. This confirms that A* does not scale well to large environments, whereas JPS-based methods efficiently handle maps of varying sizes.

The statistical results across randomized environments demonstrate that JPS–Bresenham not only outperforms JPS and A* in path quality but also maintains robust performance under diverse map complexities, validating the practicality of the proposed method for real-world UAV applications where environmental conditions are often unpredictable.

4.5. Safe Corridor Construction Results

Figure 15, Figure 16 and Figure 17 show the results of ellipsoid fitting based on directed line segments for six maps in three environments. After adding a bounding box for each segment, the fitted ellipsoids do not deviate too far from the path segments. Each segment is accompanied by an ellipsoid, which is key to generating safe corridors later. For ease of visualization, only the top view of the final results is shown.

The computation time for ellipsoid fitting is shown in

Table 6. Ellipsoid fitting computation time (seconds).

Map	Map1	Map2	Map3	Map4	Map5	Map6
Time	0.041	0.056	0.099	0.124	0.154	0.183

.

For safe corridor construction, the ellipsoid-based fitting approach efficiently generates convex polyhedra with computation times ranging from 0.041 to 0.183 s across different scenarios (Table 6). The introduction of bounding boxes effectively limits ellipsoid expansion, avoiding overly large deviations from the reference path while cutting the number of required obstacle checks by more than half. Furthermore, the overlapping corridor design enhances trajectory adaptability, as neighboring corridors share a noticeable portion of their volumes, which significantly broadens the feasible search space for back-end optimization.

The conservatism of our corridor construction is primarily determined by the ellipsoid inflation parameter $ϵ$ and bounding box constraints. Larger $ϵ$ values increase safety margins but reduce feasible space, while bounding boxes prevent excessive deviation from reference paths. In our experiments, corridor-width-to-passage-width ratios averaged 1.4–1.8 in moderately cluttered environments (Maps1–4) and increased to 2.1–2.6 in highly cluttered scenarios (Maps5–6), reflecting more conservative corridor generation as obstacle density increases. This design prioritizes safety guarantees for logistics UAVs, where collision avoidance is critical.

Despite the demonstrated advantages across varying environment complexities, our approach has certain limitations in extreme scenarios. When obstacle density exceeds 45% or when passages narrower than 0.3 m dominate the environment, the ellipsoid inflation may fail to converge within practical time limits. Additionally, in environments with highly irregular obstacle geometries (such as overhanging structures or non-convex obstacles), the ellipsoid approximation may produce suboptimal corridor shapes that restrict trajectory optimization. These cases motivate future work on adaptive corridor representation that combines ellipsoids for open regions with more flexible geometric representations for confined spaces.

4.6. Back-End Trajectory Optimization Experiments

To assess the effectiveness of the Bézier curve-based back-end trajectory optimization method, this section establishes comparative experiments between ordinary polynomials and Bézier curves based on minimum snap optimization methods. Figure 18, Figure 19, Figure 20, Figure 21, Figure 22 and Figure 23 show trajectory comparisons planned by quadrotors in different scenarios. The green trajectory in the left figure is the minimum snap trajectory optimization method based on ordinary polynomials, and the right figure is the trajectory optimization method based on Bézier curves. Points of different colors in the figure correspond to the guiding vertices of every Bézier curve section. The actually planned trajectory also satisfies the properties of Bézier curves.

This section uses Bézier curves instead of traditional piecewise polynomials to represent trajectories. Only corresponding safety and kinodynamic feasibility constraints need to be imposed on control points, without needing to find extrema and iterative solving, and without additional constraints to ensure trajectories do not collide, effectively reducing algorithm complexity. For back-end trajectory optimization, we compared the cost function (i.e., the cumulative sum of snap squared (position’s 4th-order derivative)) and the time required to generate trajectories for both methods, as shown in

Table 7. Trajectory optimization performance comparison.

Map	Integral of Snap Squared		Time (s)
	Ordinary Polynomial	Bézier Curve	Ordinary Polynomial	Bézier Curve
Map1	1576	842	0.055	0.032
Map2	796	582	0.073	0.048
Map3	2546	1470	0.086	0.063
Map4	3131	1856	0.105	0.087
Map5	4537	2105	0.158	0.103
Map6	5687	2574	0.256	0.141

. The proposed method has advantages in terms of time required to generate optimized trajectories, while also having smaller objective function values, reflecting that the generated trajectories are smoother with stable changes. Low Snap values can reduce control requirements on the system, ensure safety and stability, avoid possible energy waste, and improve overall energy utilization efficiency.

In trajectory optimization, Bézier curve representation demonstrates significant advantages over traditional piecewise polynomials. As shown in Table 7, our approach reduces snap integral by 40–55% across all scenarios, indicating substantially smoother trajectories. The computation time for optimization is reduced by 30–45%, attributed to the simplified constraint formulation enabled by the bounding envelope and velocity-hodograph characteristics of Bernstein-polynomial-based curves. The trajectories generated satisfy all kinodynamic constraints with maximum velocities and accelerations well within feasible bounds.

Visualization of the complete planning results (Figure 18, Figure 19, Figure 20, Figure 21, Figure 22 and Figure 23) reveals that our trajectories maintain smooth curvature throughout, with no abrupt direction changes or velocity discontinuities. The Bézier control points remain strictly within their respective safe corridors, confirming collision-free guarantees. Compared to ordinary polynomial trajectories, Bézier-based trajectories exhibit less oscillation near waypoints and more natural motion patterns suitable for quadrotor execution.

4.7. Motion Planning Method Comparison

To comprehensively evaluate the performance of the proposed safe-corridor-based UAV motion planning framework, this section compares it against Fast-Planner and EGO-Planner. Notably, EGO-Planner employs B-spline trajectory representation internally, so this comparison simultaneously covers B-spline-based trajectory planning methods. Kinodynamic planners target online replanning scenarios and operate under a fundamentally different problem formulation; they are therefore excluded from this offline optimization benchmark. Each method is executed ten times on randomly generated maps, and the cost function value, trajectory generation time, and success rate are recorded in

Table 8. Motion planning method comparison.

Method		Cost Function	Time (s)	Success Rate
Proposed (Safe Corridor)	Max	1024	0.44	99%
	Avg	973	0.37
	Min	958	0.34
Fast-Planner [12]	Max	1537	0.46	95%
	Avg	1323	0.41
	Min	1248	0.35
EGO-Planner [42]	Max	1489	0.43	96%
	Avg	1275	0.37
	Min	1094	0.32

.

The proposed framework is a hard-constraint optimization method that strictly enforces all constraints, guaranteeing that the final solution lies within the feasible domain. Fast-Planner and EGO-Planner are soft-constraint optimization methods that incorporate constraints as penalty terms in the objective function, permitting bounded constraint violations. Consequently, their success rates (95% and 96%, respectively) are lower than that of the proposed method (99%). When penalty coefficients are poorly tuned, soft-constraint methods may over-relax or over-tighten constraints, increasing the risk of infeasibility and local optima in multi-constraint problems.

The proposed method achieves the lowest average cost function value (973), indicating smoother trajectories with less aggressive state changes compared to Fast-Planner (1323) and EGO-Planner (1275). Trajectory generation time is comparable across all three methods. Although soft-constraint methods reduce computational overhead by converting constrained problems into unconstrained ones, the proposed method achieves competitive efficiency through the combined improvements of the JPS–Bresenham front-end path search, time allocation, and Bézier-based back-end optimization, which reduce iterative steps and complex computations without sacrificing constraint strictness.

Figure 24 further illustrates the path length and maximum acceleration of the three methods. Path lengths are similar across methods, with EGO-Planner producing the shortest paths, the proposed method second, and Fast-Planner the longest. Critically, with the maximum acceleration constraint set to $a_{max}=2\mathrm{m}/{\mathrm{s}}^2$, both Fast-Planner and EGO-Planner generate trajectories whose peak acceleration exceeds this limit—a direct consequence of soft-constraint relaxation. In practice, a UAV may be unable to track such trajectories, posing a safety risk. The proposed method strictly enforces the dynamic feasibility constraint via hard constraints, ensuring all planned trajectories remain within the prescribed acceleration bound and are therefore directly deployable on physical platforms.

5. Conclusions

The present work investigates the quadrotor motion planning problem in cluttered environments, particularly for low-altitude economy and intelligent energy system applications such as infrastructure inspection and power line monitoring, where autonomous aerial vehicles require both computational efficiency and trajectory smoothness. We introduce a complete hierarchical planning framework to efficiently generate safe, smooth, and dynamically feasible trajectories. We apply a front-end JPS–Bresenham-based path search method on grid maps to identify optimal collision-free paths with reduced waypoints and superior computational efficiency compared to sampling-based approaches. Our JPS–Bresenham algorithm achieves 4–10% shorter paths with 40–83% faster computation compared to RRT* and PRM methods. Monte Carlo experiments validate robustness with 67.3% average waypoint reduction compared to JPS and superior scalability over A*. Comparisons with state-of-the-art planners show a 99% success rate with 22–27% lower cost function values than Fast-Planner and EGO-Planner. Safe flight corridors with overlapping regions are subsequently constructed to expand the solution space, followed by time allocation for each segment. Back-end Bézier curve-based trajectory optimization leverages the convex properties of these corridors through quadratic programming, achieving significant improvements in trajectory smoothness with 40–55% reduction in snap integral and 30–45% faster computation compared to ordinary polynomial methods. Experimental validation across multiple scenarios demonstrates near-zero position and velocity tracking errors. For future work, we plan to extend the proposed framework to dynamic environments by incorporating temporal safety constraints for moving obstacle avoidance, and explore multi-drone cooperative motion planning with distributed corridor construction.

Although the proposed algorithm has been thoroughly validated through simulation experiments, real-world flight validation remains an important direction for future work. The current study is exploratory in nature, focusing on algorithmic design and performance benchmarking within controlled simulation environments. Deploying the algorithm on a physical platform would require substantial hardware infrastructure, including high-precision localization systems and reliable onboard computing units, which demands considerable engineering effort beyond the scope of this initial investigation. Moreover, systematically reproducing extreme real-world conditions, such as dynamic obstacle fields and GPS-denied environments, presents significant practical challenges. Simulation-based evaluation therefore provides a rigorous and scalable basis for assessing algorithmic performance at this stage. In future work, we plan to deploy the proposed algorithm on a physical drone platform and conduct field experiments in representative logistics scenarios to further verify its practical applicability and robustness. Additionally, we will evaluate the computational performance on resource-constrained onboard hardware to validate the method’s feasibility for time-critical applications.