The data acquisition phase employs LiDAR and 3D scanners to capture 3D point clouds of the substation environment. This study designs a point cloud preprocessing pipeline that systematically integrates data acquisition, hierarchical ground filtering, and statistically-based noise removal methods to address environmental modeling requirements in substation inspection.

To transform the continuous 3D point cloud space into a discrete representation suitable for path planning, a structured voxel grid space is constructed. The dimensions of this space are determined by the spatial distribution range of valid point cloud data. Assuming the grid map has a uniform resolution R in all three dimensions, the required number of voxels nx, ny, nz in each dimension is calculated by: (6)nθ=⌈maxi=1,2,…,Nθi−mini=1,2,…,NθiR⌉,θ=x,y,zwhere ⌈⋅⌉ represents the ceiling function, ensuring that any fractional part is allocated to a complete voxel unit, and N is the number of valid points. The span of point cloud in each dimension (maxθi−minθi) is divided by the resolution R to obtain the theoretical number of voxels required in that dimension, as described in Eq. (6). The ceiling function ensures all point cloud data are contained within the voxel space.

The mapping relationship from point cloud coordinates to voxel coordinates is defined by: (7)θ^=⌈θ−mini=1,2,…,NθiR⌉,θ=x,y,zwhere θ^ is the voxel index along the θ-axis, θ is the original point cloud coordinate, R is the voxel resolution, and ⌈⋅⌉ denotes the ceiling function.

This mapping, formulated in Eq. (7), performs a translation and scaling transformation: first, subtract the minimum value minθi of the dimension from coordinate θ to normalize to a zero-point relative coordinate system; then divide by the resolution R to discretize it to voxel indices; finally, use the ceiling function to ensure each point is uniquely assigned to a voxel. This linear mapping approach ensures efficient spatial queries and collision detection.

To ensure the flight safety of UAVs in complex substation environments, both the physical size of the UAV and a sufficient safety margin must be considered. This study employs a 3D morphological dilation algorithm to expand the safety boundaries of equipment point clouds. The core of this process is to construct a reasonable dilation radius calculation model that comprehensively considers the UAV’s physical radius ruav and the required minimum safety distance dsafe, which is defined as: (8)r=ruav+dsafewhere r is the total dilation radius, ruav denotes the physical radius of the UAV, and dsafe is the minimum required safety distance, as defined in Eq. (8).

In this work, the UAV used has a maximum diagonal dimension of approximately 0.4m, corresponding to a circumscribed radius ruav≈0.2m. An additional safety margin dsafe=0.3m is introduced to accommodate positioning errors and control uncertainties. Consequently, applying the model in Eq. (8), the dilation radius is set to r=0.5m.

This design ensures that during flight, the UAV not only avoids physical contact with obstacles but also maintains an adequate buffer zone to account for operational uncertainties, thereby meeting the safety requirements for inspection operations in dense substation environments.

Goal biasing is a crucial mechanism in sampling-based path planning algorithms. Its main idea is to select the goal point as a candidate node with a certain probability during the random sampling process, thereby accelerating the convergence of the search tree toward the goal region. In the traditional RRT algorithm, this goal biasing probability is fixed (typically between 5% and 10%), which limits adaptability in complex or dynamic environments. A fixed probability may lead to insufficient exploration in the early stage or slow convergence in the later stage.

To overcome this limitation, this paper proposes a novel mechanism for dynamic goal biasing that utilizes feedback from successful tree extensions. This mechanism adaptively adjusts the sampling probability Pgoal based on Nsuccess to dynamically balance global exploration and local convergence in real-time. The mathematical formulation of this mechanism is given in Eq. (14) as follows: (14)Pgoal(Nsuccess)=20%+Nsuccess1000×(40%−20%)

Here, Nsuccess represents the cumulative number of successful extensions. When Nsuccess=1000, the goal sampling probability reaches the upper limit of 40%. In the early stage (Nsuccess<1000), the probability remains between 20% and 30%, promoting extensive exploration and preventing premature convergence. As the search proceeds (Nsuccess≥1000), the probability increases to 40%, guiding the search tree more aggressively toward the goal and reducing unnecessary random sampling.

This adaptive mechanism enables the algorithm to maintain strong exploratory behavior in the initial phase and achieve faster convergence in the later phase, thus improving the overall planning efficiency. Moreover, it enhances the algorithm’s adaptability in dynamic and complex environments by continuously balancing global exploration and local refinement. The detailed procedure is shown in Algorithm 1.

Algorithm 1 illustrates the adaptive goal-biased sampling mechanism. The sampling probability dynamically increases with the number of successful extensions, ensuring an optimal trade-off between exploration and exploitation throughout the planning process. Computationally, this strategy introduces minimal overhead: updating Pgoal and maintaining Nsuccess are both constant-time operations (O(1) per iteration). In terms of space complexity, it requires only two scalar variables to store goal_bias and successful_searches, resulting in O(1) space overhead. Consequently, it preserves the asymptotic time and space complexity of the base RRT while significantly improving practical convergence by reducing the total number of iterations N needed to reach the goal. This dynamic biasing strategy thus enhances the robustness and efficiency of RRT-based path planning in complex UAV inspection scenarios with negligible computational cost.

RGG is an effective tool in graph theory, widely used to optimize the sampling process in path planning algorithms. In the traditional RRT algorithm, sampling points are usually completely random. The distribution of sampling points may concentrate in certain areas while neglecting others, leading to a large number of invalid nodes, especially inside obstacles or redundant regions. This results in low search efficiency and poor path quality. To address this issue, this paper proposes an optimized sampling strategy based on RGG.

In this improved strategy, we pre-generate an RGG on the map, consisting of 1000 uniformly distributed sampling points. These points not only cover various regions of the map but also avoid the node redundancy and over-concentration problems that may appear in the traditional RRT algorithm. Then, during the sampling phase of path planning, the algorithm selects the goal point with a certain probability (using the goal_bias strategy). If the goal is not selected, the algorithm chooses a sample point from the RGG that aligns with the current target direction via the function selectBestRGG. This approach ensures that the sampling points guide the search tree to grow towards the target region as much as possible. The corresponding pseudocode is provided in Algorithm 2.

To improve search efficiency, we also integrate a KD-Tree structure (rggKDTree) to quickly retrieve and select the optimal candidate sampling points. The use of KD-Tree enables near-optimal fast search in high-dimensional space, effectively reducing invalid sampling and redundant computations. Computationally, the RGG-guided sampling involves two phases with distinct complexity profiles: the offline preprocessing requires O(nrgglog⁡nrgg) time and O(nrgg) space to generate uniformly distributed points and construct the KD-Tree, while each online query performs a nearest-neighbor search in O(log⁡nrgg) time with O(1) additional space. This logarithmic query efficiency represents a significant improvement over the O(nrgg) linear scanning of all candidate points.

Collision checking is a critical component in 3D UAV path planning, as it directly affects both the feasibility of the generated path and the real-time responsiveness of the planning system. In the standard RRT algorithm, each path extension typically involves a voxel-by-voxel traversal to evaluate collisions along the entire candidate segment. This approach, while accurate in dense 3D environments reconstructed from point clouds, requires examining a large number of voxel units at each step, resulting in significant computational overhead and reduced efficiency, especially under real-time constraints.

To address this limitation, we propose a fast local collision checking strategy based on a KD-Tree structure, integrated into the improved R-RRT framework. This method constructs and dynamically maintains a KD-Tree to organize the nodes in the current search tree, enabling efficient nearest-neighbor queries in high-dimensional space. During each expansion, instead of checking the entire path globally, the algorithm performs collision detection only on the straight-line segment between the newly generated node and its nearest neighbor in the tree. This significantly reduces the number of voxel checks and accelerates the overall planning process.

More specifically, the search begins by initializing the search tree with the start node qstart and building the corresponding KD-Tree. In each iteration, a random sample qrand is drawn from the free space. The algorithm then finds the nearest node qnear from the KD-Tree and attempts to steer toward qrand, generating a new node qnew. The voxel map is queried to check whether the segment from qnear to qnew intersects any obstacles. If the segment is collision-free, qnew is added to both the search tree and the KD-Tree; otherwise, it is discarded. If qnew is sufficiently close to the goal node qgoal, the search is deemed successful.

This process is summarized in Algorithm 3, where the RRT tree and KD-Tree are initialized, and iterative sampling, extension, and collision checking are performed. If a feasible path is found, it is extracted by backtracking from the final node; otherwise, an empty path and infinite cost are returned.

The proposed KD-Tree-based local collision checking strategy is designed to accelerate the collision detection process compared to traditional voxel-by-voxel methods, with the aim of enhancing overall planning efficiency in dense 3D environments like substations. Its effectiveness will be quantitatively evaluated in the following experimental section.

The algorithm outlines the complete R-RRT planning process with KD-Tree acceleration. Computationally, the collision checking module operates in two stages with distinct complexity characteristics: offline construction of a KD-Tree from the obstacle map containing m points requires O(mlog⁡m) time and O(m) space; online querying performs each collision check by querying the k nearest obstacle points within a safety radius using the KD-Tree, which reduces the per-check time complexity from O(m) (linear scan in standard RRT) to O(klog⁡m) on average, with O(1) additional space per query. Since k is typically small and bounded, this represents a fundamental improvement that enables real-time performance in dense 3D environments.

The paths generated by the traditional RRT algorithm are typically a series of discrete and discontinuous points, suffering from issues such as excessive redundant nodes, severe path zigzags, and poor trackability, making them difficult to directly apply in practical UAV systems. To improve the executability and energy efficiency of the paths, this paper proposes a two-stage path optimization mechanism: Greedy Pruning and Gradient-Based Smoothing.

Path Pruning Optimization: Redundant nodes in the original path are recursively removed. Specifically, starting from the initial point, the algorithm checks whether the current node can directly connect to the k-th subsequent node without collision; if feasible, intermediate nodes are removed while preserving key turning points, until reaching the endpoint. This strategy effectively shortens the path length and reduces control jumps, thereby improving flight efficiency and path simplicity.

Gradient-Based Smoothing: We design a gradient descent-based path optimization method. The core idea is to minimize either the curvature variation or the jerk of the path as the objective function, while satisfying obstacle avoidance and dynamic constraints, locally adjusting the path points. By setting soft constraints (e.g., maximum offset radius) and hard constraints (e.g., no entry into obstacle regions), the algorithm gradually approaches a continuous, differentiable, and smooth trajectory, suitable for UAV control systems.

The optimization process can be expressed by the following objective function:(15)min∑i=2n−1‖xi−1−2xi+xi+1‖2where X={x1,x2,…,xn} represents the complete set of path points, and ‖xi−1−2xi+xi+1‖2 denotes the discrete approximation of path curvature at point xi. Minimizing the objective function in Eq. (15) reduces local path jerkiness while maintaining obstacle avoidance.

The optimization reduces the “zigzagging” in the path, resulting in a more coherent and smooth trajectory, which benefits UAV flight control and attitude maintenance.

The path optimization is subject to the following obstacle avoidance constraints: (16)xi∉O,∀i∈[2,n−1]where xi denotes the ith waypoint, O represents the obstacle space, and the constraint enforces collision-free intermediate path points between the fixed start (x1) and goal (xn) configurations.

The gradient-based smoothing process, governed by the objective function in Eq. (15) and the constraints in Eq. (16), is applied to enhance path continuity and safety. Computationally, the two-stage post-processing demonstrates efficiency in both time and space: for a path with p nodes, greedy pruning performs a linear pass with O(p) time complexity, while gradient-based smoothing with t iterations operates in O(t⋅p) time. In terms of space complexity, the processing requires O(p) storage for the path waypoints. Both stages utilize the same KD-Tree structure for collision checking at O(log⁡m) time per query, yielding an overall time complexity of O((t+1)⋅p⋅log⁡m). Since the number of path nodes p and the iteration count t are bounded in practical applications—with p typically small due to effective pruning—this processing meets real-time requirements while maintaining modest memory footprint. The final optimized path is designed to fulfill the direct execution needs of flight control systems, providing a stable and reliable trajectory for practical deployment.

This section provides a comprehensive theoretical complexity analysis of all path planning algorithms evaluated in this study, including the proposed R-RRT and the baseline algorithms (A*, RRT*, Bi-AM-RRT*, BTO-RRT, and CBQ-RRT*). The analysis examines both time and space complexity, as these factors jointly determine the practicality of algorithms in resource-constrained UAV systems. Let n be the number of nodes in the search tree, m the number of obstacle points in the environment, V the number of vertices in the graph representation used by A*, γ the average number of nodes within the rewiring radius of RRT* variants, and nrgg the number of pre-sampled RGG points, and Cadapt the constant per-iteration overhead for adaptive metric calculation in Bi-AM-RRT*, and Cconnect the constant per-iteration overhead for the CreateConnectNode operation in CBQ-RRT*.

Table 1 demonstrates that the proposed R-RRT achieves a time complexity of O(log⁡m+log⁡n+log⁡nrgg) by leveraging KD-Tree collision checking and RGG-guided sampling. This represents a balanced trade-off between computational efficiency and memory usage (O(m+n+nrgg)). Specifically, R-RRT trades modest increases in space (O(nrgg)) and sampling time (O(log⁡nrgg)) for a substantial reduction in overall search iterations, a strategy distinct from the constant overhead of CBQ-RRT*’s smoothing operations.

The comparison reveals a key design insight: while algorithms like RRT* and Bi-AM-RRT* suffer from the O(m) bottleneck of linear collision checking, those utilizing KD-Trees (BTO-RRT, CBQ-RRT*, R-RRT) achieve superior O(log⁡m) scalability. This efficiency comes at the cost of higher memory for the tree structure. R-RRT’s design justifies this memory investment for static inspection, as pre-computed RGG sampling dramatically reduces online planning time, outweighing the initial resource cost.

To comprehensively evaluate the path planning performance of the proposed R-RRT algorithm, experimental scenarios are designed from two perspectives: local path optimization and global path generation. All tests were conducted on a voxel grid map with a resolution of 0.5m. This resolution was chosen to balance the accuracy of environmental representation with computational efficiency for real-time planning: it matches the safety inflation radius (0.5m) to ensure adequate obstacle representation while maintaining manageable map data volume. At the local level, the equipment-intensive area between Main Transformers 1 and 2 is selected to assess the algorithm’s path smoothness and obstacle avoidance capability in dense environments. At the global level, a cross-regional path from Main Transformer 1 to the gantry structure is used to evaluate its sampling efficiency and path feasibility. Considering the stochastic nature of the algorithm, all experiments are repeated 50 times to ensure the statistical reliability of the results.

Intra-Region Path Planning: The positions of the starting and target observation points are listed in Table 2. Fig. 4 shows the path planning results for the A*, RRT*, Bi-AM-RRT*, BTO-RRT, CBQ-RRT*, and the proposed R-RRT algorithms. Table 3 provides a comparative performance analysis of the six algorithms.

Inter-Region Path Planning: The positions of starting, main transformer, and gantry observation points are given in Table 4. Fig. 5 shows the path planning results for the A*, RRT*, Bi-AM-RRT*, BTO-RRT, CBQ-RRT*, and the proposed R-RRT algorithms. Table 5 presents the performance comparison results of the six algorithms.

Figs. 4 and 5 present typical path planning results of six algorithms: A* [16], RRT* [22], the proposed R-RRT, Bi-AM-RRT* [23], BTO-RRT [24], and CBQ-RRT* [26] in the complex 3D substation environment. The path morphologies generated by these algorithms reflect their distinctive search strategy characteristics and environmental adaptability under complex obstacle distributions.

The A* algorithm demonstrates strong goal-directedness, enabling rapid approach toward the target in open areas. However, due to the inflexibility of its heuristic function in obstacle-dense regions, the path exhibits noticeable detours and sharp turns, resulting in high overall tortuosity and insufficient path smoothness.

The RRT* algorithm, expanding through random sampling, shows good obstacle avoidance capability. Nevertheless, the lack of adaptive guidance leads to “up-floating” or oscillatory paths during the search process, with relatively long path lengths and poor smoothness, which is unfavorable for stable UAV flight in complex 3D spaces.

The Bi-AM-RRT* algorithm, under the effect of bidirectional search and adaptive sampling, produces generally smoother paths. However, it still suffers from local oscillations in obstacle-intensive areas and has limited turning control capability. The BTO-RRT algorithm excels in search efficiency, achieving the shortest planning time, but its paths are longer with more frequent turns, and smoothness is slightly less smooth than R-RRT. Similarly, CBQ-RRT*, with its dual-tree and smoothing operations, enhances connectivity and smoothness to some extent; however, its paths can still show unnecessary spatial deviations and do not consistently converge to the shortest possible trajectory.

In contrast, the proposed R-RRT algorithm introduces RGG-guided sampling and a KD-tree structure into the traditional RRT framework, significantly enhancing sampling space representativeness and search efficiency. Meanwhile, the dynamic goal-biasing strategy based on successful expansion feedback maintains global exploration capability during the initial search phase and progressively strengthens convergence toward the goal direction in later stages, achieving a balance between global search and local optimality. In the post-processing phase, R-RRT employs a two-stage path optimization strategy comprising greedy pruning and gradient descent smoothing, effectively reducing redundant nodes and sharp turning points, thereby improving path continuity and flight executability.

Visually from the figures, the paths generated by R-RRT are more compact and smooth overall, capable of quickly returning to the main direction after obstacle avoidance, with minimal spatial fluctuations, gentle turning angles, and almost no sharp turns. Compared to A*, RRT*, and other algorithms, R-RRT demonstrates superior path controllability and spatial adaptability in complex obstacle environments, better meeting the requirements for smooth and executable paths in substation environments for UAVs.

The two sets of experimental data in Tables 3 and 5 quantitatively compare the performance of the six algorithms in terms of search efficiency, path quality, and smoothness metrics.

In terms of search time, BTO-RRT achieved the shortest planning time of 0.0629 s in the first experiment, while R-RRT recorded competitive times of 0.0698 and 0.0873 s in the two experiments, respectively, ranking among the fastest. Notably, in the second experiment, R-RRT’s planning time surpassed all other compared algorithms, demonstrating its stable and efficient real-time planning capability across different scenarios. Overall, while BTO-RRT was the fastest in a single trial, R-RRT achieved a superior balance between computational speed and path quality, without significantly sacrificing path optimality for extreme speed.

Regarding path length, the R-RRT algorithm achieved the shortest paths in both experiments at 323.8981 and 579.3565 m, significantly outperforming the other algorithms. This indicates that its improved sampling mechanism and goal-biasing strategy effectively reduce redundant search and enable rapid generation of near-optimal feasible paths.

In terms of path point count and turning characteristics, R-RRT generated the fewest path points (13 and 25) and significantly reduced the number of turns. Its maximum turning angles were only 67.83∘ and 7.49∘, with almost no sharp turns exceeding 45∘, outperforming algorithms such as A*, RRT*, and BTO-RRT. This demonstrates that paths generated by R-RRT are smoother and structurally simpler, effectively reducing the energy consumption and time required for UAV flight attitude adjustments.

In summary, R-RRT performs best in terms of path length, smoothness, and turning control, while BTO-RRT holds an advantage in computational efficiency. Bi-AM-RRT* shows slight improvement in path smoothness but lacks the search stability of R-RRT. Although CBQ-RRT* aims to enhance path smoothness, it still falls short in path optimality and geometric simplicity. Overall, R-RRT achieves dual excellence in both planning quality and search efficiency in complex 3D scenarios.

Integrating the qualitative and quantitative results, the improved R-RRT algorithm demonstrates outstanding path planning performance in complex 3D substation environments. By introducing RGG and KD-tree structures to enhance search efficiency, combining a dynamic goal-biasing mechanism to strengthen goal-directedness, and employing a two-stage path smoothing optimization strategy to significantly improve path continuity, R-RRT outperforms A*, RRT*, Bi-AM-RRT*, BTO-RRT, and CBQ-RRT* in path length, smoothness, and spatial adaptability. The algorithm not only generates shorter and smoother feasible paths but also exhibits clear advantages in search stability and environmental adaptability, validating the effectiveness and practical value of R-RRT for UAV path planning tasks in complex 3D spaces.