Paper deep dive
Neural-Primitive: An Efficient End-to-end Local Planner with Primitive-based Imitation Learning for Autonomous Flight
Zhitao Liu, Guangtong Xu, Zihan Wang, Jialiang Hou, Chao Xu, Fei Gao
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 8/24/2026, 5:41:07 AM
Summary
The paper introduces Neural-Primitive, an efficient end-to-end local planner for autonomous flight in cluttered environments. It addresses the computation-quality-memory trilemma by using imitation learning to map sensory inputs directly to polynomial trajectory coefficients. The method employs a lightweight offline dataset collection framework based on primitive strategies and a compact neural network that avoids back-end optimization, achieving ultra-fast computation (<1ms desktop, ~3.68ms onboard) and low memory usage (<1.5MiB). It demonstrates robust sim-to-real transfer and superior performance in simulation benchmarks compared to state-of-the-art planners.
Entities (8)
Relation Signals (6)
Neural-Primitive → achievesperformance → Ultra-fast computation
confidence 95% · It achieves ultra-fast computation (below 1ms on a standard desktop and average 3.68ms during onboard flight)
Neural-Primitive → hasauthor → Zhejiang University
confidence 95% · Affiliation: Institute of Cyber-Systems and Control, College of Control Science and Engineering, Zhejiang University
Neural-Primitive → uses → Imitation learning
confidence 95% · we propose Neural-Primitive, an efficient end-to-end local planner realized by imitation learning
Neural-Primitive → outputs → Polynomial Coefficients
confidence 90% · A compact neural network directly maps sensory inputs to polynomial coefficients
Neural-Primitive → solvesoptimizationusing → OSQP
confidence 90% · This QP (Line 10) is solved employing OSQP solver
Neural-Primitive → validateson → UAV
confidence 90% · Autonomous flight in unknown cluttered environments... for unmanned aerial vehicles (UAVs)
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Autonomous flight in unknown cluttered environments is hindered by the computation-quality-memory trilemma of onboard trajectory generation. In this paper, we propose an efficient end-to-end local planner via imitation learning. A lightweight offline-primitive-based dataset collection framework is designed to produce safe and high-quality trajectory primitives in non-convex environments. A compact neural network directly maps sensory inputs to polynomial coefficients that inherently encode higher-order dynamical information. The learned policy generates smooth, empirically collision-free and dynamically feasible trajectories in real time without back-end solving. It achieves ultra-fast computation (below 1ms on a standard desktop and average 3.68ms during onboard flight), while maintaining low onboard memory requirements (less than 1.5MiB). Extensive simulation benchmarks demonstrate superiority in both planning latency and target-reaching progress quality. Zero-shot deployment in real-world experiments further validates the robust sim-to-real transfer capability of the proposed method.
Tags
Links
- Source: https://arxiv.org/abs/2608.20948v1
- Canonical: https://arxiv.org/abs/2608.20948v1
Trouble viewing inline? Open PDF directly →
Full Text
61,920 characters extracted from source content.
Expand or collapse full text
Neural-Primitive: An Efficient End-to-end Local Planner with Primitive-based Imitation Learning for Autonomous Flight Zhitao Liu Thanks: Equal Contribution. Affiliation: Institute of Cyber-Systems and Control, College of Control Science and Engineering, Zhejiang University, Hangzhou 310027, China. Affiliation: Huzhou Institute, Zhejiang University, Huzhou 313000, China. Affiliation: Institute of Systems Engineering, China Academy of Engineering Physics, Mianyang 621999, China. Guangtong Xu Thanks: Equal Contribution. Affiliation: School of Automation, Hangzhou Dianzi University, Hangzhou 310018, China. Zihan Wang Affiliation: Department of Automation, North China Electric Power University (Baoding), Baoding 071003, China. Jialiang Hou Affiliation: Institute of Cyber-Systems and Control, College of Control Science and Engineering, Zhejiang University, Hangzhou 310027, China. Affiliation: Differential Robotics Technology Company, Hangzhou 311100, China. Chao Xu Affiliation: Institute of Cyber-Systems and Control, College of Control Science and Engineering, Zhejiang University, Hangzhou 310027, China. Affiliation: Huzhou Institute, Zhejiang University, Huzhou 313000, China. Fei Gao Thanks: E-mail: zhitaoliu@zju.edu.cn; xugt@hdu.edu.cn; 220232216066@ncepu.edu.cn; jlhou25@zju.edu.cn; cxu@zju.edu.cn; fgaoaaa@zju.edu.cn. Thanks: Our project page with videos is at https://ZhitaoLiu.github.io/neural-primitive/. Affiliation: Institute of Cyber-Systems and Control, College of Control Science and Engineering, Zhejiang University, Hangzhou 310027, China. Affiliation: Differential Robotics Technology Company, Hangzhou 311100, China. Abstract Autonomous flight in unknown cluttered environments is hindered by the computation-quality-memory trilemma of onboard trajectory generation. In this paper, we propose an efficient end-to-end local planner via imitation learning. A lightweight offline-primitive-based dataset collection framework is designed to produce safe and high-quality trajectory primitives in non-convex environments. A compact neural network directly maps sensory inputs to polynomial coefficients that inherently encode higher-order dynamical information. The learned policy generates smooth, empirically collision-free and dynamically feasible trajectories in real time without back-end solving. It achieves ultra-fast computation (below 1ms on a standard desktop and average 3.68ms during onboard flight), while maintaining low onboard memory requirements (less than 1.5MiB). Extensive simulation benchmarks demonstrate superiority in both planning latency and target-reaching progress quality. Zero-shot deployment in real-world experiments further validates the robust sim-to-real transfer capability of the proposed method. I Introduction Autonomous flight in unknown cluttered environments using only onboard noisy sensing and resource-constrained computation, epitomizes one of the grand challenges for unmanned aerial vehicles (UAVs) [24]. Despite remarkable progress [10, 17, 31], fast generation of dynamically feasible, collision-free, and efficiently target-reaching trajectories still remains open. Numerous trajectory generation approaches [30, 14, 21, 29] couple obstacle avoidance into joint optimization through strict constraints or weighted penalties. However, simultaneously considering excessive factors forces trade-offs, making solutions prone to local minima or even intractable, degrading overall trajectory quality. In contrast, motion primitive-based methods [7, 18, 4, 28] decouple obstacle avoidance out through a stepwise pipeline of free-space sampling, collision removal, and optimal selection. This facilitates near-optimal solutions but renders performance hinging on the primitive library: online-generated methods struggle to produce both dynamically feasible and diverse primitives in a short time; whereas offline-generated methods can pre-compute high-quality ones without latency concerns, yet suffer from higher-order state discontinuities during online concatenation, as the fixed library cannot cover all required initial states with limited onboard memory. Furthermore, these approaches remain subject to processing latency and compounding errors due to hierarchical planning frameworks. Recently, learning-based planning has gained significant attention [5, 13, 23]. Although claiming end-to-end planning capability, most still require online back-end optimization [6], closed-form solving [13], or projection [10] after network inference to yield controller-executable trajectories, ultimately restricting achievable planning efficiency. These methods invariably face a computation-quality-memory trilemma, namely the inability to simultaneously satisfy fast online computation, near-optimal target-reaching trajectories, and low onboard memory consumption. To address the aforementioned challenges, we propose Neural-Primitive, an efficient end-to-end local planner realized by imitation learning of a customized offline primitive strategy. Unlike naive replication of existing planners, which is limited by expert performance, we inherit the core idea from offline primitive library-based methods, namely generating high-quality primitives through sampling-exploration and obstacle-avoidance-decoupling. At the same time, we resolve their major drawbacks (high-order discontinuities and storage burden of large libraries) by employing online inference with a compact neural network (memory size less than 1.5MB). We design a primitive-strategy-embedded dataset collection procedure that mitigates covariate shift [3] without resorting to resource-intensive approaches such as DAgger [20]. This enables subsequent training to capture precise target-reaching behaviors in cluttered environments. Compared with existing learning-based planners, our policy directly predicts polynomial coefficients from sensory inputs, intrinsically encoding high-order dynamical information and producing practically controller-executable trajectories without back-end solving11 1 “Without back-end solving” means that no additional optimization, quadratic programming, or boundary-value problem solving is needed after network inference.. This design results in a highly integrated end-to-end planning scheme. Together with a streamlined network architecture that avoids convolutions and other costly operations, the proposed method achieves ultra-fast computation (<< 1ms on standard desktop and mean 3.68ms onboard) while maintaining consistency across scenarios. To bridge the sim-to-real gap from sensory mismatch, we design a point cloud preprocessing technique that adapts to obstacle density variations. This boosts robustness and generalization atop domain randomization. Consequently, our method achieves fast online generation of near-straight trajectories toward the target across unknown cluttered environments. We benchmark with representative state-of-the-art local planners [30, 29, 17, 13] through extensive simulations. Statistical results demonstrate superior performance in computation time, success rate, flight length, and flight time. The generalization and sim-to-real capabilities of the proposed method are further validated in complex previously unseen maps and real-world experiments. The contributions of this paper are summarized as follows: 1. A lightweight offline-primitive-based dataset collection framework, which efficiently produces safe and high-quality trajectory primitives in non-convex environments. 2. A compact imitation learning neural network, which can output polynomial coefficients empirically satisfying safety, dynamical feasibility, and target-reaching progress quality under the supervision of the expert dataset, with enhanced generalization capability enabled by the proposed point cloud pre-processing training technique. 3. An ultra-fast and high-quality end-to-end local planner, which directly maps sensory inputs to high-order continuous polynomial trajectories without back-end solving. 4. Comprehensive simulation benchmarks and zero-shot deployment in real-world experiments are conducted to validate the superiority of our method. I Related Work Fig. 1: System overview. The end-to-end planner generates smooth, empirically collision-free and dynamically feasible trajectories directly from onboard sensory inputs. (A) Training datasets are collected entirely in simulation using a customized primitive strategy. (B) A neural network learns to predict polynomial coefficients that inherently encode high-order dynamical information for direct execution by the low-level controller. (C) The learned policy is zero-shot deployed for fast online inference in previously unseen environments without fine-tuning. I-A Primitive-based Motion Planning for UAV Primitive-based methods cast motion planning as primitive selection, enhancing solution space multimodality through free-space sampling and obstacle-avoidance decoupling. Based on primitive library generation, they can be categorized into online and offline approaches. In [18, 26, 9], polynomial trajectory candidates are obtained online by sampling terminal states and solving boundary value problems (BVPs) in closed form. However, dynamical feasibility is not considered during generation and must be verified individually through post-checking [16]. Some works [25, 2, 4] sample control inputs and generate primitives online through forward calculation with simplified motion models, which can accommodate input limits but degrade trajectory quality due to model inaccuracy. Online methods can hardly generate trajectory primitives with sufficient diversity and quality within a short planning horizon. Conversely, studies [27, 28] generate plenty of path primitives offline for online selection, but geometric paths neglect dynamical properties (velocity, acceleration, etc.), thus fail to ensure higher-order continuity during online concatenation. Hou et al. [7] further generate time-optimal trajectory primitives offline with dense initial velocity discretizations to promote velocity continuity, but acceleration continuity still remains unresolved. In practice, although offline methods offer broad primitive coverage regardless of latency concerns, storing all high-order initial states for online concatenation without exceeding onboard memory is nearly infeasible (a rough estimate based on [7] indicates that covering initial states up to 3m/s and 3m/s2 with 0.1 steps would require far more than 1000GB of memory), leaving discontinuity an inherent unresolved drawback. I-B Learning-based Motion Planning for UAV Neural networks, with their strong capacity for environmental abstraction and rapid online inference, show promising potential in enhancing UAV motion planning efficiency. Wu et al. [23] use a network to predict time allocations for piecewise trajectories, but still rely on the traditional hierarchical pipeline of mapping, path finding, and trajectory optimization, leading to high computational cost. In [6, 5], networks replace mapping and path finding, but online optimization is still required for generating executable trajectories. The network in [13] predicts end-state terms for pre-sampled primitives and solves one online via a closed-form BVP back-end. However, dynamical process constraints are not explicitly enforced, and its coupled training objective introduces inherent trade-offs, making solutions prone to local minima. Loquercio et al. [10] utilize a network to output waypoints, but they contain only geometric information without dynamical properties, requiring real-time projection after network inference to obtain polynomial trajectories. Overall, existing learning-based planning methods have yet to fully demonstrate end-to-end planning without back-end trajectory solving, and direct generation of controller-executable trajectories with efficient target-reaching progress quality still remains improvable. I System Overview Fig. 1 illustrates the three-stage pipeline of the proposed system. Firstly, all training datasets are collected in simulation, incorporating a customized primitive strategy to strengthen the dynamical feasibility, collision avoidance, and task-oriented trajectory quality of the expert primitives. The resulting primitive from each successful replanning step is stored along with the perceived point clouds, drone states, and target direction. Instead of saving path points that only represent geometric positions [10], the polynomial coefficients of the parameterized primitive are recorded, which inherently encode high-order dynamical information. Subsequently, a policy network based on multilayer perceptrons (MLPs) is trained offline in a supervised manner utilizing the pre-collected datasets. It learns to generate continuous primitives from discrete samples, predicting polynomial coefficients from sensory inputs. This addresses the velocity or acceleration discontinuity issue inherent in traditional offline primitive library-based planning methods [7, 28, 27], while also eliminating the need for back-end trajectory solving [12, 13, 6, 23, 5] or projection [10] required in existing learning-based planning approaches, thereby enabling an end-to-end planning framework. To reduce the sensory gap for sim-to-real transfer, point clouds are preprocessed prior to formal training and augmented with Gaussian noise, which is also injected into other inputs to enhance generalization. Finally, the learned policy is zero-shot deployed onboard for inference in previously unseen environments without any fine-tuning. It directly maps onboard sensory data to practically executable trajectories in a receding-horizon fashion, which are sent to the low-level controller for execution. IV Methodology IV-A Primitive Strategy Embedded Dataset Collection IV-A1 Collection Procedure Dataset generation for imitation learning needs to account for the covariate shift [3] arising from distribution mismatch between expert demonstrations and real-world deployment. Rather than relying on resource-intensive methods like DAgger [20], we collect the full dataset prior to training. Specifically, data are obtained in a closed-loop manner, recording only those from the successful completion of randomly initialized navigation tasks. Evidently, replanning can be triggered at arbitrary initial states throughout the process. However, constructing a large offline library covering all the states for selection is infeasible due to overwhelming memory and computation burden. Therefore, we propose a dataset collection procedure embedded with a customized primitive strategy, as detailed in Algorithm 1. Input: nmaxn_max, nthrdn_thrd, Θmap _map, Θinit _init, Θlib _lib Output: D 1 ←∅D← , nvalid←0n_valid← 0 2 while nvalid<nmaxn_valid<n_max do 3 ℳ←randomMapGen(Θmap)M← randomMapGen( _map) 4 forall thrdi∈1,…,nthrdthrd_i∈\1,…,n_thrd\ do in parallel 5 0,target,0←randomInitGen(Θinit) s_0, p_target, d_0← randomInitGen( _init) 6 temp.clear()D_temp.clear() 7 while truetrue do 8 ℒ.clear()L.clear() 9 forall f∈endStateSet(Θlib) s_f∈ endStateSet( _lib) do 10 ←solveQP(0,f,τ,Θlib) ξ← solveQP( s_0, s_f,τ, _lib) 11 ←sampleTraversalVoxels()O← sampleTraversalVoxels( ξ) 12 ℒ.pushback(prim(,))L.pushback(prim( ξ,O)) 13 ←sensePointCloud(0,ℳ)P← sensePointCloud( s_0,M) 14 ℒsafe←collisionLabeling(ℒ,,RWV)L_safe← collisionLabeling(L,P,R^V_W) 15 prim∗←selectBest(ℒsafe,target,RWV)prim^*← selectBest(L_safe, p_target,R^V_W) 16 if prim∗isemptyprim^*\ is\ empty then 17 break 18 ∗←prim∗.getCoeffs() c^*← prim^*.getCoeffs() 19 0,0←0.getVelAcc() v_0, a_0← s_0.getVelAcc() 20 temp.pushback(data(0,0,0,,∗))D_temp.pushback(data( v_0, a_0, d_0,P, c^*)) 21 0,0←executeTraj(prim∗) s_0, d_0← executeTraj(prim^*) 22 if targetReach(0,target)targetReach( s_0, p_target) then 23 ←∪tempD _temp 24 nvalid←nvalid+temp.size()n_valid← n_valid+D_temp.size() 25 break 26 if nvalid≥nmaxn_valid≥ n_max then 27 terminate all threads return D Algorithm 1 Dataset Collection with Primitive Strategy A randomized simulation map ℳM is first generated from given parameters Θmap _map (Line 3). Then up to nthrdn_thrd navigation tasks run in multithreaded parallel to accelerate the process. Each task randomly initializes the target position target p_target and drone state 0 s_0 based on boundary values defined in parameters Θinit _init, spanning diverse initial drone-target configurations, with 0 d_0 denoting the normalized target direction vector. A trajectory library with occupancy relations, conditioned on the current state, is regenerated at the beginning of each replanning step (Lines 8-12, detailed in Section IV-A2), eliminating the need for a large-scale precomputed library. Unsafe primitives are rapidly identified and excluded based on perceived point clouds and preassigned occupancy relations, then the safest one is chosen by a composite cost function (Lines 13-15, detailed in Section IV-A3). If a valid primitive is found, the corresponding data, containing velocity 0 v_0, acceleration 0 a_0, direction 0 d_0, perceived point clouds P, and polynomial coefficients ∗ c^* of the selected primitive, are stored in a temporary buffer tempD_temp. The primitive is then partially executed to update the drone state. Only when the drone reaches the target within a predefined tolerance is tempD_temp appended to the final dataset D. This helps encode drone-target proximity and enables the network to learn precise reaching behavior from the dataset. The process repeats with new maps until the valid data number nvalidn_valid reaches nmaxn_max, after which the full dataset D is returned. IV-A2 Trajectory Library with Occupancy Relations The library ℒL is constructed via state lattice discretization, with state dimensions extending to acceleration. Since the initial state 0 s_0 is already known at the replanning step, only terminal states f s_f need to be sampled (Line 9), which significantly reduces the library size. The offline process further enables multi-constraint optimization to generate a set of candidate primitives that are both dynamically feasible and spatially diverse without considering latency. The trajectory primitive (t)∈ℝ3 ξ(t) ^3 is parameterized as a single-segment polynomial vector function in three-dimensional space: (t) ξ(t) =[x(t),y(t),z(t)]T∈ℝ3=T(t), =[x(t),y(t),z(t)]^T ^3= c^T β(t), (1) where c =[xyz]∈ℝ(n+1)×3, =[ c_x\ c_y\ c_z] ^(n+1)× 3, μ c_μ =[cnμ,…,c2μ,c1μ,c0μ]T∈ℝn+1,μ∈x,y,z, =[c_nμ,…,c_2μ,c_1μ,c_0μ]^T ^n+1,\;μ∈\x,y,z\, (t) β(t) =[tn,…,t2,t,1]T∈ℝn+1,t∈[0,τ]. =[t^n,…,t^2,t,1]^T ^n+1,\ t∈[0,τ]. here x(t)x(t), y(t)y(t) and z(t)z(t) are the drone positions; n is the polynomial order; ∈ℝ(n+1)×3 c ^(n+1)× 3 is the coefficient matrix; and τ is the fixed time duration. We solve for the primitive coefficients with minimum control effort. Let ¯=vec()∈ℝ3(n+1) c=vec( c) ^3(n+1) denote the column-wise vectorization of c. Owing to the differential flatness of quadrotors [15], the optimization problem can be formulated as the convex quadratic program (QP) below: min¯ cmin ¯T¯, c^T Q c, (2) s.t. ¯=, A c= b, (3) ¯≤. G c≤ h. (4) where ∈ℝ3(n+1)×3(n+1) Q ^3(n+1)× 3(n+1) is the positive semidefinite quadratic cost matrix; (3) & (4) represent the boundary and dynamical constraints, respectively, with limits specified in parameters Θlib _lib. Specifically, ∈ℝ6Nb×3(n+1) A ^6N_b× 3(n+1) and ∈ℝ6Nb b ^6N_b are the boundary constraint matrix and vector, with NbN_b denoting the number of derivative orders enforced at boundary points, satisfying n=2Nb−1n=2N_b-1; ∈ℝ6(Nb−1)Ns×3(n+1) G ^6(N_b-1)N_s× 3(n+1) and ∈ℝ6(Nb−1)Ns h ^6(N_b-1)N_s are the dynamical constraint matrix and vector, with NsN_s denoting the number of uniformly sampled time points for dynamical limit checking. This QP (Line 10) is solved employing OSQP solver [19]. In this work, we consider minimum-jerk trajectories with n=5n=5, Nb=3N_b=3 (constraining position, velocity, and acceleration), Ns=20N_s=20, and τ=2τ=2s. The boundary constraints on start states are taken from the current drone state at each replanning step, while the terminal ones are sampled from the end-state lattice. The primitives and all other stored data are expressed in a velocity-aligned frame ℱVF_V, where the x-axis is aligned with the drone’s velocity vector, the z-axis opposes the gravity vector g, and the y-axis completes the right-handed coordinate system. All primitives share the same origin at zero position in this frame. Inspired by [7], we additionally construct occupancy relations in this stage to enable subsequent fast collision checking. In ℱVF_V, a bounding box enclosing all primitives is discretized into small voxels and organized as a kd-tree. For each primitive, the indices of all traversed voxels within an inflated collision radius are retrieved and stored in a hash-based set, which defines its occupancy relations O (Line 11), representing the spatial region occupied by the inflated primitive. Binding these relations directly to the corresponding primitive also helps form an implicit primitive-obstacle relationship, benefiting subsequent network learning. The complete trajectory library ℒL comprises all optimized primitives along with their associated occupancy relations (Line 12). IV-A3 Collision Labeling and Best Primitive Selection The perceived point clouds are downsampled to a fixed size and mapped into the bounding box to obtain the corresponding voxel indices (Line 13), where RWVR^V_W denotes the rotation matrix from the world frame ℱWF_W to frame ℱVF_V. A primitive is labeled unsafe and removed from the library if any of these indices are contained in its occupancy relations (Line 14). This process is highly efficient, as voxel inclusion is checked via hash lookup, and a primitive is marked unsafe once the first matching voxel is found. Moreover, it eliminates frequent Euclidean Signed Distance Field (ESDF) queries required by existing learning-based methods during data collection or training [5, 12, 13, 6], making it resource-friendly as well. The best primitive is selected from the remaining safe candidates via a task-oriented cost function (Line 15): =wttarget+wllength.C=w_tC_target+w_lC_length. (5) where wtw_t and wlw_l are the weights; targetC_target and lengthC_length are the target-approach cost and primitive-length cost, respectively, calculated by: target=‖(τ)−targetℱV‖,if ‖targetℱV‖>‖(τ)‖,mini=0,…,N‖(ti)−targetℱV‖,otherwise.C_target= cases\| ξ(τ)- p_target^F_V\|, \| p_target^F_V\|>\| ξ(τ)\|,\\ i=0,…,Nmin\| ξ(t_i)- p_target^F_V\|, . cases (6) length=∑i=0N−1‖(ti+1)−(ti)‖.C_length= _i=0^N-1\| ξ(t_i+1)- ξ(t_i)\|. (7) where targetℱV p_target^F_V is the target position vector in frame ℱVF_V; ti=iτNt_i= iτN, with N being the discrete sample number for the primitive. Note that targetC_target encodes the primary objective of target reaching. Its piecewise formulation promotes forward progress when the target lies beyond the primitive’s reachable range, while preventing overshoot to facilitate precise target acquisition when the target is within reach. Meanwhile, lengthC_length serves as a geometric regularizer that penalizes unnecessarily curved or weaving primitives and favors more direct trajectories. We clarify the optimality of the expert strategy at two levels. a) Individual-primitive level: each candidate primitive is the optimal solution of a constrained minimum-jerk QP under its conditioned boundary states, dynamical limits, and fixed duration. It is optimal in the minimum-control-effort sense, not in the time-optimal sense. b) Library-selection level: the expert strategy pursues spatial optimality through a step-wise pipeline of free-space sampling, collision removal, and optimal selection. This design decouples obstacle avoidance from goal reaching, avoiding the trade-offs of jointly optimizing both in a single objective, and thus yields spatially near-straight expert trajectories. IV-B Fast End-to-end Trajectory Planning Framework We expect to perform fast online inference of executable trajectories relying solely on onboard sensors. To this end, we consider the following characteristics: a) End-to-end policy: Unifying the mapping, front-end path searching, and back-end trajectory solving within the classical planning framework into an integrated process, thereby eliminating inter-module latency and compounding errors; b) Executable outputs: Incorporating state continuity, target-reaching progress quality, and empirical obstacle avoidance and dynamical feasibility for direct execution by low-level controller; c) Lightweight network: With low inference computation and memory consumption, enabling efficient real-time onboard deployment. The framework consists of the following four components: IV-B1 Policy Input-Output Design To eliminate the need for back-end trajectory solving, the policy is intended to directly output the polynomial coefficients. For a minimum-jerk primitive expressed in frame ℱVF_V, the coefficient matrix in (1) can be expanded as: =[ab],a=[c5xc5yc5zc4xc4yc4zc3xc3yc3z],b=[12a0x12a0y12a0z‖0‖00000]. c= bmatrix c_a\\[2.0pt] c_b bmatrix,\; c_a= bmatrixc_5x&c_5y&c_5z\\ c_4x&c_4y&c_4z\\ c_3x&c_3y&c_3z bmatrix,\; c_b= bmatrix 12a_0x& 12a_0y& 12a_0z\\ \| v_0\|&0&0\\ 0&0&0 bmatrix. (8) It can be seen that b∈ℝ3×3 c_b ^3× 3 governs state continuity and can be directly determined from the current velocity 0 v_0 and acceleration 0 a_0. In contrast, a∈ℝ3×3 c_a ^3× 3 needs to be learned to satisfy obstacle avoidance and target-reaching progress quality, which are associated with the perceived point clouds P and the target direction 0 d_0, respectively. By imitating expert coefficients that are carefully selected into the training dataset, the empirical dynamical feasibility of the inferred trajectories can also be reinforced. Therefore, the policy network is designed to take ‖0‖∈ℝ1\| v_0\| ^1, 0∈ℝ3 a_0 ^3, 0∈ℝ3 d_0 ^3 and ∈ℝm×3P ^m× 3 as inputs and output a∈ℝ9 c_a ^9, where a c_a is expanded into a vector here and m denotes the number of 3D point clouds, thereby enabling end-to-end generation of executable trajectories from sensory data without any further solving. IV-B2 Network Architecture We present Npe2eNet, shown in Fig. 1B, which primarily comprises a point cloud encoder, a feature fusion module, and a coefficient prediction head. The encoder plays a pivotal role in capturing environmental context. It first pre-processes arbitrary-sized point clouds to a fixed mfixm_fix points (set to 666 to balance input size and perceptual sufficiency). Each point’s 3D coordinates pass through an MLP ([128, 128, 64], ReLU), followed by max-pooling to a 64-D global descriptor, which is refined by another MLP ([64, 32], ReLU) to a 32-D representation. This is concatenated with the 7-D state into a 39-D input to a feature fusion MLP ([256, 512, 256], ReLU), yielding a compact yet expressive feature vector that encapsulates environmental, dynamical and target information. This feature finally feeds a coefficient prediction MLP ([128, 128, 9], ReLU) to output the nine polynomial coefficients. Npe2eNet adopts a streamlined architecture that avoids complex operations like convolutions. It can be calculated that the network only contains approximately 0.355M parameters with a computational cost of approximately 34M FLOPs. The model occupies about 1.38MiB of storage. During online inference, the per-forward-pass consumes about 0.65MiB peak incremental memory and 11.49MiB peak total memory of GPU22 2 Peak incremental memory measures extra dynamic GPU memory for inference operation only, while peak total memory measures the overall dynamic GPU memory needed for inference, including model parameters, input tensors, intermediates, etc.. Compared with existing learning-based methods built on heavier architectures such as ResNet[12, 13], MobileNet[10], and Transformer[5], its resource demands are substantially lower, enabling fast and efficient real-time inference. IV-B3 Training Method In real flights, perceived point clouds vary significantly in density and spatial distribution across scenarios, and drone state measurements are inherently noisy. These discrepancies, arising from sensory mismatch, primarily constitute the sim-to-real gap in the end-to-end planning scheme. To bridge this gap and enhance the generalization capability of the simulation-trained policy for zero-shot transfer, we implement two strategies during training: 1) Point cloud pre-processing: Considering that real flight point clouds may deviate from the fixed network input size mfixm_fix and the simulation dataset cannot cover all variations, we resample the dataset point clouds before formal training. For each data sample, with probability prop_pro, the point cloud is downsampled by a factor r of its original size, where r is randomly selected from [rmin,1][r_min,1] and 0≤rmin≤10≤ r_min≤ 1. If the resulting size is smaller than mfixm_fix, it is padded with points whose coordinates are assigned large values (set as 100), denoting distant obstacles; otherwise, it is randomly downsampled to mfixm_fix. This broadens density coverage and mitigates unseen scenes during training. Note that in online inference stage, the input point clouds are directly downsampled or padded to mfixm_fix. 2) Domain randomization: Gaussian noise is injected into both the input state values and the coordinates of the pre-processed point cloud, with standard deviations set to proportions rσsr_ _s and rσpr_ _p of their respective magnitudes. This further improves the robustness of the policy network against sensory noise. IV-B4 Loss Function The network is trained to minimize the Mean Squared Error (MSE) loss between expert coefficients a∗ c_a^* and predicted values ^a c_a: ℒcoeff=MSE(a∗,^a)=1M∑k=1M(ca,k∗−c^a,k)2.L_coeff=MSE( c_a^*,\, c_a)= 1M _k=1^M(c_a,k^*- c_a,k)^2. (9) where subscript k indexes the M elements of a∈ℝ3×3 c_a ^3× 3, with M=9M=9. AdamW optimizer [11] (learning rate lr=1.0×10−3lr=1.0× 10^-3, weight decay =1.0×10−4=1.0× 10^-4) with cosine annealing scheduling (half-cycle length Tmax=0.3×T_max=0.3×maximum epochs, minimum learning rate ηmin=0.1×lr _min=0.1× lr) is utilized to ensure fast, stable convergence and mitigate overfitting. Training employs a batch size of 128 (validation 64), with a maximum of 600 epochs and early stopping patience of 20. V Evaluations V-A Implementation Details We conduct dataset collection, network training, and simulation tests on a desktop computer with i7-10700K CPU, GTX 1060 GPU and Ubuntu 20.04 system. The randomized simulation maps for dataset collection consist mainly of cylinders, rectangular columns, and rings, with overall obstacle densities ranging from 1/40 to 1/4. A total of one million valid samples are collected, with each requiring only approximately 0.08s to generate, and the data are stored in H5 format for training the network via PyTorch. The resulting policy model is deployed to ROS via LibTorch for online inference. In real-world experiments, we implement the learned policy model on a quadrotor without any further fine-tuning. The platform integrates a Livox Mid-360 LiDAR33 3 https://w.livoxtech.com/mid-360 for onboard sensing, an NVIDIA Jetson Orin NX44 4 https://w.nvidia.com/en-us/autonomous-machines/embedded-systems/jetson-orin/ for end-to-end planning and SE(3) geometric tracking control[8], and a PX455 5 https://px4.io/ flight controller for low-level attitude control. The planned trajectory is executed in an event-triggered receding-horizon manner. Specifically, replanning is triggered by whichever of the following conditions occurs first: the quadrotor travels the preset distance threshold drep=0.5d_rep=0.5m, the execution time reaches the upper limit Trepmax=2τ/3T_rep =2τ/3, or a potential collision is detected. This mechanism allows the actual execution time to adapt naturally to the flight speed while remaining within the valid time window [0,τ][0,τ]. Additionally, each inferred trajectory undergoes a lightweight post-inference collision check [30, 31, 17] before being sent to the controller. The first two-thirds of the trajectory are sampled at intervals of 0.05s and queried against an inflated occupancy grid via an O(1)O(1) lookup. Note that the checker operates in an independent parallel module outside the end-to-end trajectory generation pipeline and serves as a decoupled engineering safeguard against rare inputs outside the training distribution. V-B Ablation Study Fig. 2: Benchmark results under different obstacle densities. (A) Example (successful) trajectories in dense scenarios. (B) Computation time, where “Mapping” includes grid map, point cloud map, and ESDF construction, “Front” denotes path finding and corridor generation, “Back” indicates trajectory optimization or closed-form BVP solving, and “Model” refers to network inference. (C) Success rate. (D) Flight length. (E) Flight time. (F) Energy cost. (G) Overall comparison across the five metrics. We first conduct a series of ablation experiments to examine how the training augmentation techniques affect network performances, with a focus on the key parameters in the domain randomization (i.e., rσsr_ _s and rσpr_ _p) and point cloud pre-processing (i.e., prop_pro and rminr_min) modules. All experiments are performed in 50×20×10m simulated maps with dense obstacle configurations (160 cylinders and 40 rings, minimum spacing 2m, and overall density 1/5). The drone autonomously navigates a 64m start-target distance, with success defined as reaching the target without collision (drone radius 0.15 m) and within a 1m target tolerance. The maximum speed is limited to 4m/s. Each ablation setting is evaluated over 250 runs. In every run, obstacle positions and radii are randomly generated. Gaussian noise with zero mean and a 5% standard deviation is injected into both the network input states and point cloud coordinates to emulate measurement uncertainties. The results are reported in Table I and Table I. TABLE I: Ablation study on domain randomization parameters No. rσsr_ _s rσpr_ _p Success Rate A0 0.00 0.00 0.904 A1 0.03 0.03 0.924 A2 0.03 0.04 0.936 A3 0.04 0.04 0.912 A4 0.06 0.06 0.892 • Note: conducted with the point cloud pre-processing module disabled TABLE I: Ablation study on point cloud pre-processing parameters No. prop_pro rminr_min Success Rate B0 0.0 1.0 0.936 B1 0.3 0.7 0.944 B2 0.6 0.5 0.972 B3 0.6 0.3 0.932 B4 0.9 0.1 0.888 • Note: conducted on top of the selected A2 domain randomization setting TABLE I: Sensitivity analysis on point cloud input size mfixm_fix Success Rate Inference Latency (ms) Peak Incremental Memory (MiB) Peak Total Memory (MiB) 333 0.916 0.43 0.325 11.162 666 0.972 0.67 0.650 11.491 1024 0.968 0.78 1.003 11.844 2048 0.976 0.93 2.001 12.856 Experiments A0 to A4 assess different (rσsr_ _s, rσpr_ _p) combinations under domain randomization, with the point cloud pre-processing module disabled. Compared with the baseline A0, success rates are observed to improve in A1 to A3 when noise is added to state values and point cloud coordinates during training. These perturbations enhance robustness to proprioceptive and exteroceptive disturbances, respectively, and mitigate overfitting to idealized clean observations. However, excessive noise, as in A4, degrades performance due to distortion of the original observation distribution and impairment of stable input-output learning, leading to potential misinterpretation of obstacles and targets. By evaluating both symmetric and asymmetric combinations, we select A2 (rσsr_ _s=0.03, rσpr_ _p=0.04, and success rate 0.936) as the domain randomization setting. Experiments B0 to B4 further investigate the impact of different (prop_pro, rminr_min) combinations with the point cloud pre-processing module added on top of domain randomization, where A2 serves as the baseline B0. For autonomous flight in clutters, point clouds encode critical obstacle constraints for safe navigation. Previous noise injection on point cloud coordinates essentially perturbs spatial positions only, but overlooks variations in point cloud density. The proposed pre-processing module exposes the network to a broader density range during training, enhancing adaptation to fluctuations in obstacle point counts. Consequently, success rates are further improved (as in B1 and B2) over the domain randomization baseline B0 in complex scenarios. Moreover, prop_pro governs the pre-processing frequency, while rminr_min sets the lower bound for point cloud density. Insufficient prop_pro or excessive rminr_min fails to capture density fluctuations adequately, leading to marginal robustness improvements in B1. Conversely, excessively high prop_pro paired with minimal rminr_min causes over-sparsification, eroding the obstacle geometric fidelity within the dataset and in turn compromising success rates in B3 and B4. The balanced configuration B2, with prop_pro = 0.6 and rminr_min = 0.5, achieves a peak success rate of 0.972. These results verify the efficacy of the proposed point cloud pre-processing strategy. We further conduct a sensitivity analysis on the fixed point cloud input size mfixm_fix, examining its effects on success rate, inference latency, peak incremental memory, and peak total memory. The results are reported in Table I. It can be seen that reducing mfixm_fix to 333 lowers latency and memory consumption, which is reasonable since the point cloud encoder operates in a point-wise manner, making latency and dynamic memory scale with input size. However, the success rate in case 333 drops to 0.916, indicating insufficient environmental information for reliable planning compared to case 666. Moreover, increasing mfixm_fix to 1024 and 2048 yields only marginal changes in success rate, but incurs higher latency and memory costs, with peak incremental memory rising by 54.3% and 207.8%, respectively. These results indicate that case 666 offers a favorable balance among planning reliability, computational efficiency, and memory cost. V-C Acceleration Continuity Analysis To demonstrate the resolution of the acceleration discontinuity inherent in traditional offline primitive library-based planners, we compare with the single version of Primitive-swarm [7] and plot the curves (Fig. 3) under dense environments. It is evident that acceleration jumps occur throughout the entire flight of [7]. This occurs because the library cannot cover all possible acceleration states due to size constraints for onboard memory and latency. As a result, when an uncovered initial acceleration arises during online selection, discontinuities appear, degrading trajectory quality and increasing motor load. In contrast, our method explicitly considers higher-order state continuity when designing the network input and output, thereby successfully addressing this problem. Fig. 3: Acceleration curves. Our method overcomes the high-order state discontinuity problem of traditional offline library-based planners [7]. V-D Benchmarks In this section, we compare the proposed method with four representative local planners, including three well-established approaches under the classical hierarchical planning framework and one state-of-the-art learning-based planner, namely: 1) Fast[29]: Kinodynamic path searching on an incrementally updated voxel map, followed by gradient-based trajectory optimization relying on a constantly maintained ESDF for safety regularization; 2) Ego[30]: A∗ path searching on the constructed grid map, with subsequent ESDF-free trajectory optimization leveraging collision costs derived directly from grid-obstacle information; 3) Super[17]: Path searching and flight corridor generation directly on an efficient spatiotemporal sliding point cloud map, followed by MINCO-based [22] dual-trajectory optimization that jointly accounts for high-speed exploration and safety assurance; 4) Yopo[13]: Objective-function-guided unsupervised learning for the network, inferring the end-state related terms of all pre-sampled primitives from sensory inputs, after which one is selected for closed-form BVP solving. All planners are tested in simulated maps with different obstacle densities. The autonomous navigation task and dense environment configuration follow those described in Sect. V-B. The sparse configuration consists of 40 cylinders and 10 rings, with a minimum spacing of 4m and an overall density of 1/20. All baselines are evaluated with their official open-source implementations and default parameters. For a fair comparison, all planners use the same 90∘×60∘ Field-of-View (FOV), collision radius of 0.15m, maximum velocity of 4m/s, and simulator (including the controller and quadrotor model) adopted from [29]. The target reaching tolerance is still set to 1m, but relaxed to 4m for Yopo, as it cannot satisfy stricter tolerances. Each planner is evaluated over 100 runs in both dense and sparse scenarios, with obstacles randomly generated in each run. Flight visualizations and statistical results are presented in Fig. 2. It can be seen that our method outperforms the baselines in both sparse and dense environments (Fig. 2G), whereas the baselines, despite performing well in sparse settings, deteriorate in dense scenarios. In terms of computation time (Fig. 2B), Fast incurs the highest cost, primarily due to ESDF maintenance. Although Ego and Super avoid this overhead, they still require grid map construction or point cloud-based corridor generation, so their planning time is highly sensitive to obstacle density and increases with it. Yopo circumvents mapping and front-end processing, running faster than the first three methods in dense environments. However, in sparse settings, its runtime even slightly exceeds Ego due to the need for inference over all pre-sampled primitives, complex in-network operations, and back-end BVP solving costs. Consequently, when grid map construction exerts less influence in sparse environments, Yopo loses its efficiency advantage over Ego. Our method achieves the shortest computation time, averaging 0.70ms (sparse) and 0.68ms (dense), about 7 to 60 times faster than the baselines, with stable efficiency independent of densities due to its highly integrated end-to-end planning policy and compact yet effective architecture. Regarding task-oriented trajectory optimality (Fig. 2D and Fig. 2E), the four baselines yield longer and slower trajectories than the proposed method. This arises from their strong coupling of obstacle avoidance and goal navigation into a complex multi-constraint optimization problem (including Yopo, which essentially formulates the same problem but solves it with a neural network). As a result, they must trade off among competing factors, often becoming trapped in local minima and producing detours, as shown in Fig. 2A. By contrast, our method benefits from imitating the customized primitive strategy that decouples the two problems by first eliminating colliding primitives and then concentrating on selecting the task-oriented optimal primitive from the safe set, thereby avoiding compromises for obstacle avoidance. This design enables near-direct flight distances (64.51m in dense and 64.39m in sparse) and the shortest flight time to the target. Fig. 2F shows the energy cost measured by the integral of squared-jerk. Consistent with the trajectory results, our method yields lower accumulated squared-jerk than Ego and Super, while the lower values of Fast and Yopo are achieved at the expense of substantially longer detours and less direct motion toward the target. This indicates that our method achieves a favorable balance between efficient target reaching and energy consumption. Finally, while the other planners exhibit declining success rates in dense environments, our method sustains the highest rate of 0.97 (Fig. 2C). This stems from its ultra-low latency, enabling rapid responses to dense obstacles even at high speeds, further reinforced by point-cloud pre-processing and domain randomization for robust environmental abstraction. Fig. 4 plots success rates against increasing average speeds for all compared planners. Results indicate that all methods achieve perfect success rates at low speeds (≈ 2m/s). However, performance degrades significantly for Fast, Ego, and Yopo as speed increases, particularly in dense scenarios. In contrast, Super and our proposed method maintain success rates above 0.80 even at high average speeds of around 6m/s. The decline for Fast and Ego primarily arises from hierarchical latency and compounding errors. Moreover, their joint optimization processes frequently converge to local minima, failing to generate safe trajectories under high speed motion. For Yopo, we observe inconsistent velocity profiles characterized by abrupt accelerations, leading to collisions when obstacles appear suddenly. Furthermore, the lack of explicit density-aware training also limits its generalization across varying obstacle configurations. Although Super employs a hierarchical planning structure, its complex dual-trajectory mechanism ensures an effective balance between speed and safety. Our method achieves comparable success rates to Super but avoids its extensive hand-crafted rules and pronounced trajectory detours as demonstrated in Fig. 2A. Through a streamlined end-to-end architecture, our approach produces straighter flight paths while maintaining the same high level of robustness. Fig. 4: Success rates across average speeds. (A) Results in sparse environments. (B) Results in dense environments. Fig. 5: Generalization test environments. The main panels show the global top view, while the adjacent insets present the corresponding first person views of the indexed local regions. (A) Point cloud map collected from real world forests [1]. (B) Simulated 3D obstacle map resembling caves and mountainous terrain [6]. V-E Generalization Evaluations To evaluate the generalization capability of the proposed planner, we test the learned policy via simulation in environments not encountered during training. Two types of more complex new maps are employed: 1) an open-sourced point cloud map collected from real-world forests [1], which we crop to a volume of 60×50×20m. This map contains not only tree trunks, branches, and ground vegetation, but also spatially distributed noise points, as illustrated in Fig. 5A; and 2) a simulated unstructured 3D obstacle map resembling caves and mountainous terrain [6], generated using Perlin noise with dimensions of 60×50×10m. In this second map, obstacles exhibit diverse irregular shapes and varying densities that differ from those in the training datasets, as shown in Fig. 5B. For each map type, we perform 150 autonomous traversal trials. Start and target positions are randomly initialized with separation distances of 70∼ 80m per trial. The policy is the one obtained from ablation experiment B2 in Sect. V-B, without any fine-tuning to the new environments. The resulting success rates are 0.907 and 0.833, respectively. It can be seen that although performance degrades relative to training environments, a common limitation of learning-based methods, the results still remain high and exceed those reported in [6]. This robustness is attributed to the synergistic effects of domain randomization and point cloud pre-processing. These strategies improve tolerance to spatial noise while enhancing adaptability to density variations. Consequently, the proposed planner achieves comparable generalization across both noise-corrupted and density-varying new environments. V-F Real-world Experiments We validate our method through real-world experiments in both outdoor unknown forests and indoor cluttered environments. All scenarios are previously unseen, and the training data come solely from simulation without real-world fine-tuning. We refer readers to the supplementary video for more information. As illustrated in Fig. A, we first conduct the outdoor navigation experiments in a non-uniform forest with approximately 1/6 trees/m2 density and 0.3m average tree diameter. Each tree is irregularly surrounded by multiple tilted wooden stakes, forming a complex cluttered environment. The results show that the quadrotor autonomously flies to a target 60m ahead (within 1m reaching tolerance) under random disturbances including wind and sensor noise. It reaches a maximum speed of 6.10m/s, completes the flight within 12s without collisions, and maintains a nearly straight trajectory without significant detours, demonstrating effective sim-to-real transfer capability. Fig. 6 presents the statistics of onboard planning time for end-to-end planning throughout the entire flight. The mean is 3.68ms with a standard deviation of ± 0.77ms. The median is as low as 3.43ms, with values ranging from 2.71ms to 5.94ms. These metrics highlight the exceptional computational efficiency of the proposed method for onboard deployment. Fig. 6: Statistics of onboard planning time. The distribution characterizes the superior real-time onboard efficiency of the proposed end-to-end local planner with a mean planning time of only 3.68ms throughout the flight. Fig. 7: Field snapshots and onboard planning visualizations in thick foliage. Red spheres and blue curves denote current positions and planned trajectories, respectively. The quadrotor performs safe and robust maneuvering through restricted spaces with a minimum passage under 0.8m. The flight performance in a denser forest with thick foliage is depicted in Fig. 7. Despite the cluttered obstacles and the narrowest passage under 0.8m (quadrotor diameter ≈ 0.3m), the planner can still successfully generate safe trajectories and execute traversal maneuvers. Furthermore, we also conduct indoor experiments in a confined space with randomly placed obstacles, as shown in Fig. B. The quadrotor needs to sequentially visit multiple preset targets within a 0.5m reaching tolerance before proceeding to the next. This experiment validates the stability and safety of the proposed planner during continuous multi-target navigation in unknown, cluttered environments. VI Conclusion and Future Work This paper leverages imitation learning to inherit the advantages of offline primitive-based methods in generating high-quality trajectories, while addressing their inherent discontinuity drawback through online network inference. The resulting planner directly outputs polynomial coefficients from sensory inputs. It produces practically controller-executable trajectories without back-end solving and forms a highly integrated end-to-end planning scheme. The proposed point cloud pre-processing technique during training improves success rates across varying obstacle densities and enhances generalization capability. Extensive benchmarks against state-of-the-art baselines in both dense and sparse environments demonstrate consistent superiority in computation time, success rate, flight length, and flight time. Furthermore, zero-shot deployment in indoor and outdoor real-world experiments validates the robustness and efficiency of the proposed planner. Nevertheless, we acknowledge that the current framework is primarily designed for static obstacles and remains limited in handling highly dynamic obstacles. Moreover, as a local planner relying on instantaneous limited Field-of-View inputs, it may struggle to escape large local traps such as dead ends and U-shaped obstacles. Overcoming these limitations will be investigated as our future work. References [1] K. Chaney, F. Cladera, Z. Wang, A. Bisulco, M. A. Hsieh, C. Korpela, V. Kumar, C. J. Taylor, and K. Daniilidis (2023) M3ed: multi-robot, multi-sensor, multi-environment event dataset. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, p. 4016–4023. Cited by: Fig. 5, §V-E. [2] M. Collins and N. Michael (2020) Efficient planning for high-speed mav flight in unknown environments using online sparse topological graphs. In 2020 IEEE International Conference on Robotics and Automation (ICRA), p. 11450–11456. Cited by: §I-A. [3] J. J. Damanik, J. Jung, C. A. Deresa, and H. Choi (2024) Lics: navigation using learned-imitation on cluttered space. IEEE Robotics and Automation Letters. Cited by: §I, §IV-A1. [4] M. Dharmadhikari, T. Dang, L. Solanka, J. Loje, H. Nguyen, N. Khedekar, and K. Alexis (2020) Motion primitives-based path planning for fast and agile exploration using aerial robots. In 2020 IEEE International Conference on Robotics and Automation (ICRA), Vol. , p. 179–185. Cited by: §I, §I-A. [5] Z. Han, M. Tian, Z. Gongye, D. Xue, J. Xing, Q. Wang, Y. Gao, J. Wang, C. Xu, and F. Gao (2025) Hierarchically depicting vehicle trajectory with stability in complex environments. Science Robotics 10 (103), p. eads4551. Cited by: §I, §I-B, §I, §IV-A3, §IV-B2. [6] Z. Han, L. Xu, L. Pei, and F. Gao (2025) Dynamically feasible trajectory generation with optimization-embedded networks for autonomous flight. IEEE Robotics and Automation Letters 10 (10), p. 9995–10002. External Links: Document Cited by: §I, §I-B, §I, §IV-A3, Fig. 5, §V-E. [7] J. Hou, X. Zhou, N. Pan, A. Li, Y. Guan, C. Xu, Z. Gan, and F. Gao (2025) Primitive-swarm: an ultra-lightweight and scalable planner for large-scale aerial swarms. IEEE Transactions on Robotics. Cited by: §I, §I-A, §I, §IV-A2, Fig. 3, §V-C. [8] T. Lee, M. Leok, and N. H. McClamroch (2010) Geometric tracking control of a quadrotor uav on se (3). In 49th IEEE conference on decision and control (CDC), p. 5420–5425. Cited by: §V-A. [9] Y. Lee, J. Park, B. Jeon, S. Jung, and H. J. Kim (2024) BPMP-tracker: a versatile aerial target tracker using bernstein polynomial motion primitives. IEEE Robotics and Automation Letters 9 (12), p. 10938–10945. Cited by: §I-A. [10] A. Loquercio, E. Kaufmann, R. Ranftl, M. Müller, V. Koltun, and D. Scaramuzza (2021) Learning high-speed flight in the wild. Science Robotics 6 (59), p. eabg5810. Cited by: §I, §I, §I-B, §I, §I, §IV-B2. [11] I. Loshchilov and F. Hutter (2017) Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101. Cited by: §IV-B4. [12] J. Lu, B. Tian, H. Shen, X. Zhang, and Y. Hui (2023) LPNet: a reaction-based local planner for autonomous collision avoidance using imitation learning. IEEE Robotics and Automation Letters 8 (11), p. 7058–7065. Cited by: §I, §IV-A3, §IV-B2. [13] J. Lu, X. Zhang, H. Shen, L. Xu, and B. Tian (2024) You only plan once: a learning-based one-stage planner with guidance learning. IEEE Robotics and Automation Letters 9 (7), p. 6083–6090. Cited by: §I, §I, §I-B, §I, §IV-A3, §IV-B2, §V-D. [14] M. Lu, X. Fan, H. Chen, and P. Lu (2025) FAPP: fast and adaptive perception and planning for uavs in dynamic cluttered environments. IEEE Transactions on Robotics 41 (), p. 871–886. External Links: Document Cited by: §I. [15] D. Mellinger and V. Kumar (2011) Minimum snap trajectory generation and control for quadrotors. In 2011 IEEE International Conference on Robotics and Automation (ICRA), p. 2520–2525. Cited by: §IV-A2. [16] M. W. Mueller, M. Hehn, and R. D’Andrea (2015) A computationally efficient motion primitive for quadrocopter trajectory generation. IEEE transactions on robotics 31 (6), p. 1294–1310. Cited by: §I-A. [17] Y. Ren, F. Zhu, G. Lu, Y. Cai, L. Yin, F. Kong, J. Lin, N. Chen, and F. Zhang (2025) Safety-assured high-speed navigation for mavs. Science Robotics 10 (98), p. eado6187. Cited by: §I, §I, §V-A, §V-D. [18] M. Ryll, J. Ware, J. Carter, and N. Roy (2019) Efficient trajectory planning for high speed flight in unknown environments. In 2019 International conference on robotics and automation (ICRA), p. 732–738. Cited by: §I, §I-A. [19] B. Stellato, G. Banjac, P. Goulart, A. Bemporad, and S. Boyd (2020) OSQP: an operator splitting solver for quadratic programs. Mathematical Programming Computation 12 (4), p. 637–672. Cited by: §IV-A2. [20] K. Tejaswi and T. Lee (2022) Constrained imitation learning for a flapping wing unmanned aerial vehicle. IEEE Robotics and Automation Letters 7 (4), p. 10534–10541. Cited by: §I, §IV-A1. [21] M. Wang, Q. Wang, Z. Wang, Y. Gao, J. Wang, C. Cui, Y. Li, Z. Ding, K. Wang, C. Xu, et al. (2025) Unlocking aerobatic potential of quadcopters: autonomous freestyle flight generation and execution. Science Robotics 10 (101), p. eadp9905. Cited by: §I. [22] Z. Wang, X. Zhou, C. Xu, and F. Gao (2022) Geometrically constrained trajectory optimization for multicopters. IEEE Transactions on Robotics 38 (5), p. 3259–3278. Cited by: §V-D. [23] Y. Wu, X. Sun, I. Spasojevic, and V. Kumar (2024) Deep learning for optimization of trajectories for quadrotors. IEEE Robotics and Automation Letters 9 (3), p. 2479–2486. Cited by: §I, §I-B, §I. [24] G. Yang, J. Bellingham, P. E. Dupont, P. Fischer, L. Floridi, R. Full, N. Jacobstein, V. Kumar, M. McNutt, R. Merrifield, et al. (2018) The grand challenges of science robotics. Science robotics 3 (14), p. eaar7650. Cited by: §I. [25] X. Yang, A. Agrawal, K. Sreenath, and N. Michael (2019) Online adaptive teleoperation via motion primitives for mobile robots. Autonomous Robots 43 (6), p. 1357–1373. Cited by: §I-A. [26] X. Yang, J. Cheng, and N. Michael (2021) An intention guided hierarchical framework for trajectory-based teleoperation of mobile robots. In 2021 IEEE International Conference on Robotics and Automation (ICRA), p. 482–488. Cited by: §I-A. [27] J. Zhang, R. G. Chadha, V. Velivela, and S. Singh (2018) P-cap: pre-computed alternative paths to enable aggressive aerial maneuvers in cluttered environments. In 2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), p. 8456–8463. Cited by: §I-A, §I. [28] J. Zhang, C. Hu, R. G. Chadha, and S. Singh (2020) Falco: fast likelihood-based collision avoidance with extension to human-guided navigation. Journal of Field Robotics 37 (8), p. 1300–1313. Cited by: §I, §I-A, §I. [29] B. Zhou, F. Gao, L. Wang, C. Liu, and S. Shen (2019) Robust and efficient quadrotor trajectory generation for fast autonomous flight. IEEE Robotics and Automation Letters 4 (4), p. 3529–3536. Cited by: §I, §I, §V-D, §V-D. [30] X. Zhou, Z. Wang, H. Ye, C. Xu, and F. Gao (2020) Ego-planner: an esdf-free gradient-based local planner for quadrotors. IEEE Robotics and Automation Letters 6 (2), p. 478–485. Cited by: §I, §I, §V-A, §V-D. [31] X. Zhou, X. Wen, Z. Wang, Y. Gao, H. Li, Q. Wang, T. Yang, H. Lu, Y. Cao, C. Xu, et al. (2022) Swarm of micro flying robots in the wild. Science Robotics 7 (66), p. eabm5954. Cited by: §I, §V-A.