Automated guided vehicle (AGV) path optimization method based on improved rapidly-exploring random trees

Principles of the RRT path optimization algorithm

The RRT algorithm (Zhang et al., 2025) is a tree-structured path optimization model. It begins by identifying the start and goal points, creating an initial tree structure with the start point as the root node. Subsequently, it randomly samples new points within the entire search space. By calculating the Euclidean distance between the newly sampled point and each node in the existing tree structure, the algorithm identifies the nearest node to the new point. Starting from this nearest node, it extends a certain step size in the direction of the new sample point to generate a new node. The algorithm then checks whether the new node lies within an obstacle region; if it does, the node is discarded, and the sampling and extension process is repeated. This process of random sampling and extension continues, with the tree structure growing and spreading to gradually explore the entire space. After each extension, the algorithm checks whether the newly generated node is near the goal point or can directly connect to it. If the condition is met, a path from the start point to the goal point is found. The overall process is illustrated in Fig. 1.

The expansion principle of nodes during the path node search process can be expressed as:

(1) $$v=(x_{rand}-x_{near},y_{rand}-y_{near})$$ (2) $$\hat{v}=\frac{v}{\parallel v\parallel }=\frac{x_{rand}-x_{near},y_{rand}-y_{near}}{\sqrt{{(x_{rand}-x_{near})}^2+{(y_{rand}-y_{near})}^2}}$$ (3) $$v=\mathrm{\nabla }\hat{v}$$ (4) $$x_{new}=x_{near}+v_{new}=x_{near}+\mathrm{\nabla }$$where $v$ represents the vector pointing from the nearest node to the random point, and the unit vector $v$ is obtained by normalizing $\hat{v}$. Starting with the initial point $x_{init}$ as the root node of the path, a random sample point $x_{rand}$ is generated within the search space. $x_{near}$ is the nearest child node to this random point. A new child node $x_{new}$ is expanded along the line connecting $x_{near}$ and $x_{rand}$ with a fixed step size. If $x_{new}$ does not collide with any obstacles, it is added to the path nodes of the rapidly exploring random tree; otherwise, the point is discarded, and $x_{new}$ is regenerated. The above steps are repeated until $x_{new}$ reaches the goal point or its vicinity, thereby finding a planned path from $x_{init}$ to the goal point.

Conversion relationship between AGV operating speed and search step size

The step size in the RRT algorithm represents the straight-line distance between two nodes in the path, which corresponds to the distance traveled by the AGV between two steering actions in its driving path. This distance is determined by two factors: the action time of the AGV’s automatic control and the vehicle’s driving speed. According to the technical requirements of AGVs, the minimum action frequency for the autonomous steering control is 2 Hz. The distance traveled by the vehicle between two steering actions is defined as the step size for vehicle path planning, which can be expressed as the product of the vehicle speed and the steering time interval (Mao, Lv & Quan, 2025):

(5) $$r=u\bullet t$$where $u$ represents the AGV’s motion speed, and $t$ denotes the time interval between steering actions; $r$ is the actual step size at different speeds. When running the RRT algorithm, the actual step size is converted into a pixel step size by incorporating the scale of pixels in the image.

Research on AGV path planning algorithms

In the field of AGV path planning, researchers have proposed various algorithms to improve the navigation capabilities of AGVs in complex environments. These algorithms can be broadly categorized into traditional path planning methods, optimization-based path planning methods, learning-based path planning methods, and hybrid path planning methods. Traditional path planning methods mainly include algorithms such as A*, Dijkstra, and RRT. These algorithms are based on graph search, topological structures, or tree structures and can effectively solve path planning problems in static environments. For instance, the A* algorithm finds the shortest path from the start to the goal through heuristic search and is widely used in AGV path planning; Dijkstra’s algorithm is suitable for finding the shortest path in complex networks and is commonly used in more dynamic environments. However, these traditional algorithms have limitations in handling dynamic environments and real-time obstacle avoidance, as they have relatively high computational complexity and are prone to “curse of dimensionality” in high-dimensional spaces. Optimization-based path planning methods, which incorporate particle swarm optimization, genetic algorithms, and other techniques, optimize AGV path planning by constructing optimization objective functions that comprehensively consider factors such as the shortest distance, smoothness, and obstacle avoidance. These optimization algorithms perform well when dealing with multi-objective and multi-constraint problems, but they typically require high computational costs and may not be able to respond in real-time in dynamic environments. Path planning methods based on deep learning and reinforcement learning, with their adaptability and learning capabilities, can better cope with changes in dynamic environments. However, issues such as long training times and large data requirements remain bottlenecks limiting their widespread application.

The RRT algorithm and its improved versions have been widely applied to path planning problems, especially in complex environments. The RRT algorithm can quickly find a feasible path in a large space by rapidly expanding the tree, making it particularly suitable for high-dimensional space path planning. RRT uses a randomized method to expand the tree structure, efficiently exploring the space and finding feasible paths, which is very suitable for path planning in dynamic environments. However, the paths generated by the traditional RRT algorithm are often rough, lack smoothness, and have limitations in computational efficiency and dynamic obstacle avoidance capability (Caccavale & Finzi, 2022). To address these issues, researchers have proposed various improved algorithms, such as RRT*, Density Gradient-RRT (Huang, Fan & Sun, 2024), Quick-RRT* (Cui et al., 2024), Bi-directional RRT (Sheng et al., 2025), and the Convex Decomposition-based Real-Time Optimal Path Planning algorithm (CDRT-RRT*) (Liu et al., 2025). These improved algorithms optimize path quality, reduce path roughness, increase path expansion speed, and enhance obstacle avoidance capabilities. Among them, RRT* achieves asymptotic optimality of the path by optimizing the cost function of the path; Quick-RRT accelerates the tree expansion speed, thus improving the algorithm’s computational efficiency; Bi-directional RRT expands from both the start and goal simultaneously, reducing path planning time; Density Gradient-RRT considers density information during tree expansion, further improving path quality. CDRT-RRT* improves computational efficiency by dividing the environment into simpler convex regions through convex segmentation, reducing the complexity of path planning, and effectively avoiding obstacles in dynamic environments. However, there are still limitations when dealing with real-time obstacle avoidance, path smoothness, and expansion efficiency in high-dimensional spaces. In environments with significant changes, the convex segmentation method may incur additional computational overhead, thus increasing the time required for path updates. Therefore, future research will focus more on the intelligence and adaptability of algorithms to meet the increasingly complex path planning requirements.

Path optimization strategy for the improved RRT algorithm

This article ingeniously integrates the adaptive step size optimization strategy, the KD-Tree fast search mechanism, and the cubic spline function path optimization. The adaptive step size optimization strategy dynamically adjusts the step size based on different scene: it reduces the step size when approaching the target point to improve precision and performs fine adjustments when encountering obstacles to prevent new nodes from crossing them, thereby significantly enhancing the accuracy of path planning. The KD-Tree fast search mechanism accelerates the search speed for the nearest node, markedly improving the algorithm’s performance and enabling more efficient path planning in complex environments. The cubic spline path optimization smooths the generated path, making it more aligned with practical application requirements and further enhancing the quality of path planning. Through the organic combination of these three techniques, the efficiency and quality of path planning in complex environments can be effectively improved. The improved RRT algorithm process is shown in Fig. 2, and its corresponding pseudocode is presented in Algorithm 1.

Adaptive step size optimization strategy

In the traditional fixed-step RRT algorithm, the same step size is used regardless of environmental changes, which can lead to slow searches and wasted computational resources in open areas. The adaptive step size can increase the search stride in such cases, quickly covering more areas, improving search efficiency, and reducing computation time. During AGV path planning, when approaching the target or navigating complex terrain, a fixed step size may cause the algorithm to miss the target, making it difficult to accurately find a feasible path. This article adopts an adaptive step size optimization strategy, which can reduce the step size for fine-grained searches, allowing the path to more precisely approach the target and increasing the likelihood of the algorithm model finding the optimal path (Wang et al., 2023). First, the algorithm continuously monitors the distance between the current node and the target node. When the distance falls below a specific threshold, the adaptive adjustment mechanism is triggered, and the system enters a fine operation mode. The distance between nodes is accurately measured using the Euclidean distance formula, which can be expressed as:

(6) $$d(A,B)=\sqrt{{(x_2-x_1)}^2+{(y_2-y_1)}^2}$$where $d(A,B)$ represents the distance between two nodes, where A and B are two nodes in a two-dimensional search space with coordinates $(x_1,y_1)$, $(x_2,y_2)$. The step size is dynamically adjusted based on the distance between nodes during the search. In areas closer to the target or with more complex environments, the step size is reduced to improve search precision. In areas farther from the target or with simpler environments, the step size is increased to accelerate the search speed. This approach effectively enhances the planning quality and computational efficiency of the algorithm.

Assume the current node is $(x_1,y_1)$, and the set of coordinates for the target node and obstacles is C. The minimum Euclidean distance between the current node and the set C is calculated as $d$. The step size update strategy is as follows:

(7) $$\mathrm{\nabla }={\mathrm{\nabla }}_{min}+\frac{{\displaystyle d-d_{min}}}{d_{max}-d_{min}}({\mathrm{\nabla }}_{max}-{\mathrm{\nabla }}_{min})$$where $d_{min}$ and $d_{max}$ are distance thresholds, and ${\mathrm{\nabla }}_{min}$ and ${\mathrm{\nabla }}_{max}$ are step size thresholds. When $d\le d_{min}$, the search is conducted with a smaller step size, and when $d>d_{max}$, the search is conducted with a larger step size. In AGV path planning, the distance threshold and search step size are adjusted based on the geometric characteristics of the target area. Specifically, $d_{max}$ represents the AGV’s maximum travel range, which is set based on the longest straight-line distance to the target area. $d_{min}$ is determined according to the minimum side length or radius of the target area, typically ranging from 0.2 to 0.4 times the minimum side length or radius, ensuring that the AGV can accurately approach the target by reducing the search step size when it gets closer. The minimum search step size is also set within the range of 0.2 to 0.4 times the minimum side length or radius of the target area, ensuring fine adjustments. The maximum search step size is determined by the AGV’s maximum search speed, ensuring efficient movement during path planning.

Nearest neighbor fast search and node expansion mechanism

KD-Tree (Guo et al., 2023; Sulistianto, Pratama & Widyawan, 2024) is a data structure based on binary trees, commonly used for data storage and search in high-dimensional spaces. In path planning, each node represents a position in space, and the node’s attributes include position coordinates and possibly other relevant information. When constructing a KD-Tree, the data is first preprocessed by collecting spatial position data points, removing outliers and erroneous data, and normalizing the data. Next, the dimension with the largest data variance is selected for partitioning, typically choosing the median of the data to split it into two parts. The process is then repeated on each part to construct subtrees until the stopping conditions are met. In nearest neighbor search, starting from the root node, the search subtree is determined by comparing the target node’s coordinates with the current node’s partitioning dimension. The search continues until a leaf node is reached or the stopping condition is met, at which point the nearest neighbor is recorded, and backtracking occurs to check for closer neighbors. The process involves calculating the distance from the target node to the hyperplane dividing the current node, and continuously updating the nearest neighbor during the search. Finally, based on the nearest neighbor and the information from the backtracking process, a path from the start position to the target position is constructed. This path can be refined by progressively connecting the nodes and optimizing the initial path, checking for collisions with obstacles, and making adjustments, resulting in an optimized path output.

Compared to traditional point-to-point search methods, KD-Tree can quickly narrow down the search range by using spatial partitioning and hierarchical organization, rapidly locating the nearest neighbor node, thereby reducing search time. This is especially advantageous in large-scale node cases and is effective in handling high-dimensional data, adapting to different dimensional space environments. When dealing with dynamic environments, path planning not only relies on 2D position coordinates but also involves multiple dimensions such as speed, acceleration, and load, which collectively determine the motion state of the AGV. As an efficient data structure, KD-Tree can real-time obtain the position and status of obstacles and adjust the path accordingly, helping the AGV avoid obstacles in real-time. In terms of computational complexity, traditional point-to-point search methods have a complexity of $O(n)$. The construction of KD-Tree requires sorting the data and selecting the dimension with the largest variance for partitioning. The time complexity of each partitioning step is $O(nlogn)$, and the nearest neighbor search is used to find the optimal path. In the worst case, the computational complexity of KD-Tree is $O(n+logn)$, and the average computational complexity is $O(logn)$, which is significantly better than traditional path planning algorithms. This efficient search capability makes KD-Tree suitable for high real-time and high-efficiency dynamic path planning, ensuring that the AGV can complete tasks quickly and safely in complex environments.

The construction process of a KD-Tree mainly consists of the following three steps: (1) Determine the split dimension: For all K-dimensional data, calculate the variance of each data point in each dimension respectively. Select the dimension corresponding to the maximum variance value as the value of the split dimension. The larger the variance, the more scattered the data is in the direction of that coordinate axis, and the higher the resolution of the data. (2) Determine the root node: Sort the K-dimensional data according to the value of the split dimension, and the median data point is the root node of the KD-Tree. (3) Determine the left and right subspaces: After determining the root node, the data on the left side of the root node forms the left subtree, and the data on the right side forms the right subtree. Then, select the split dimensions for the K dimensions in turn to build the split dimensions of each layer of the subtree. Subsequently, repeat steps (2) and (3) for the left subtree and the right subtree respectively until there is only the last node left in each subspace. The overall algorithm flow is shown in Fig. 3.

Cubic spline path smoothing processing

The cubic spline function (Lu & Chen, 2024; Li et al., 2024) is a piecewise cubic polynomial function commonly used to construct smooth curves between a series of discrete points. In the path smoothing process, assuming the ordered path points are $(x_i,y_i)$ (where $i=0,1,...,n$), to ensure smooth connections between the path points, a function $y=s(x)$ is required such that it is a cubic polynomial in each interval $[x_i,x_{i+1}]$. The cubic spline function $s(x)$ in each interval $[x_i,x_{i+1}]$ can be expressed as:

(8) $$s(x)=a_i(x-x_i{)}^3+b_i(x-x_i{)}^2+c_i(x-x_i)+d_i$$where $a_i$, $b_i$, $c_i$, and $d_i$ are coefficients to be determined. The cubic spline interpolation function must satisfy certain continuity and smoothness conditions at these points, including continuity of the function value, first derivative, and second derivative. At the node $x_i$, the function values on the left and right sides must be equal, ensuring that the path does not exhibit jumps when transitioning from one interval to another. For two adjacent nodes $x_i$ and $x_{i+1}$, the smoothness constraints can be expressed as:

(9) $$s(x_i)=s(x_{i+1})$$

(10) $$s^{\prime }(x_i^{-})=s^{\prime }(x_i^{+})$$

(11) $$s^{″}(x_i^{-})=s^{″}(x_i^{+})$$where the first derivative constraint ensures smoothness in the tangential direction of the path, while the second derivative constraint ensures smoothness in the curvature of the path. To uniquely determine the coefficients of the cubic spline function, boundary conditions for solving the coefficients must also be defined. Common boundary conditions include natural boundary conditions and fixed boundary conditions. Natural boundary conditions are suitable for cases where there are no special constraints at the ends of the path, allowing for natural curvature. Fixed boundary conditions are used when the starting and ending directions of the path are known. In this article, to make AGV path planning more flexible, natural boundary conditions are adopted as the boundary constraints for solving the coefficients, i.e., $s^{″}(x_0)=0$ and $s^{″}(x_n)=0$.

By applying the aforementioned continuous smoothness constraints and boundary constraints, a system of linear equations for the coefficients of the cubic spline interpolation function can be established. Solving this system of linear equations yields the coefficients corresponding to the interpolation function in each sub-interval, which enables the calculation of path points within these intervals and thereby constructs a smooth path. Implementing cubic spline interpolation for smoothing the planned optimal path can refine the original discrete path into a more continuous trajectory, further enhancing the quality of path planning.

Experimental setup

To validate the performance of the improved algorithm in path planning, this article conducts comparative experiments between the enhanced RRT algorithm and traditional RRT, RRT*, and Informed-RRT* algorithms. Under the same experimental conditions, path planning is performed using maps of varying scales, as shown in Fig. 4. The three test scene all feature maps with dimensions of $800m\times 800m$. Scenario 1 represents a factory area with cylindrical obstacles that are sparsely distributed, designed to test the algorithm’s decision-making capabilities when faced with multiple path choices. Scenario 2 simulates a warehouse with neatly arranged shelf obstacles, replicating path planning in a structured goods storage space. Scenario 3 involves a complex goods placement area with uniformly arranged but variably sized obstacles, further simulating path planning in narrow passages. The performance of the path planning is evaluated based on two metrics: path length and planning time. The experiments are conducted on a computer equipped with an Intel^® Core™ i9-14900HX 2.20 GHz processor, 32 GB RAM, an NVIDIA RTX 4070 Ti GPU, and MATLAB 2024 (The MathWorks, Natick, MA, USA).

Result analysis

Figure 5 presents a visual comparison of the planning results of the four path-planning algorithms across different scenario maps. The comparison demonstrates that the improved algorithm proposed in this article achieves superior planning performance in all three test scene. It effectively reduces unnecessary exploration in irrelevant regions while delivering smoother path transitions at turning points.

Using average search time and average path length as evaluation metrics, a comparison of the different algorithms is presented in Table 1. The results demonstrate that the improved RRT algorithm achieves significant enhancements in both path length and search time. Compared to the traditional RRT, RRT*, and Informed-RRT* algorithms, the average path length is reduced by 164.33 units, and the average search time is shortened by 3.39 s. In the improved algorithm, the incorporation of an adaptive step size optimization strategy and a nearest-neighbor fast search method effectively reduces the randomness of the planning process. This results in more stable planning outcomes, better meeting the path-planning requirements of AGVs in practical applications.

Convergence analysis

During the path planning process, by continuously updating the positions of nodes and combining with an optimization algorithm, it is ensured that the path length is the shortest and obstacles are avoided, so as to obtain the optimal path. At the same time, the stability and safety of the path also need to be considered to deal with possible path changes or dynamic movement of obstacles, thus ensuring the feasibility and efficiency of the path. In order to analyze the convergence of the proposed method and the comparative methods, Scene 2 and Scene 3 are used as experimental test data to evaluate the convergence speed and stability of different algorithms in different scene.

As shown in Fig. 6, the variation of the planned distance with the number of iterations for each path optimization algorithm is illustrated. By comparison, it can be observed that the proposed method exhibits a significantly faster convergence rate than the RRT, RRT*, and Informed-RRT* algorithms. Under the same number of iterations, the proposed method achieves a shorter planned path, and for the same path length, it requires fewer iterations, further validating the effectiveness of the proposed method.

Significance analysis

To quantify the improvement in path planning performance of the proposed algorithm compared to other algorithms, this study conducted 50 independent repeated experiments for four algorithms. Paired sample t-tests were used for statistical analysis at a significance level of $\alpha =0.01$. Additionally, to control for the multiple comparison issue, the Bonferroni correction was applied. This further assessed whether the proposed algorithm exhibited statistically significant differences in path planning performance. The results of the statistical analysis were considered reliable and valid. Typically, a significance threshold of 0.01 is used, and when the p-value is less than 0.01, it is concluded that there is a significant difference in path planning performance between the proposed algorithm and other algorithms. The statistical results for the proposed algorithm’s path planning performance are shown in Table 2.

Based on the experimental results, our proposed algorithm demonstrates significant performance advantages across three test scenarios. In terms of path planning, the proposed method reduced the path length by 164.3–308.0 m compared to the RRT, RRT*, and Informed-RRT algorithms, with all p-values for the comparisons being less than 0.01, indicating a significant optimization effect. In terms of time efficiency, the proposed method saved 1.97–24.04 s compared to the other algorithms, and the absolute t-values for the three scenarios were all greater than 5.6, further validating that the proposed method is highly statistically significant.

Experimental study on hyperparameters

In path planning algorithms, the distance threshold for determining whether a new node is close to the target point is a critical parameter. When the distance from the new node to the target point is less than this threshold, the new node is considered to be close to the target point. A smaller threshold may make it more difficult for the algorithm to find a path close to the target point, leading to increased search time, while a larger threshold may result in less precise paths. Therefore, to thoroughly investigate the impact of the distance threshold on path planning, experiments were conducted using three different map scene. In the experiments, the distance threshold between the new node and the target point ranged from 10 to 120, and the test results for different thresholds are shown in Table 3. The comparison reveals that when the distance threshold between the new node and the target point is set to 80, the path from the start point to the end point is optimal, allowing the path planning to be completed in less time while ensuring the highest quality of path planning.

To provide a clearer comparison of the impact of different threshold parameter values on path planning, we visualized the path planning results for Scene 3 under various threshold conditions, as shown in Fig. 7. The comparison reveals that when the threshold is set to 65, the path planning process requires the least time, and the path length is also the shortest. When the threshold is set to a smaller value, the planned path exhibits a more intricate and detailed exploration pattern on the map, and the algorithm requires more time to find a path close to the target point. This aligns with the characteristic of smaller thresholds, which demand that new nodes must be very close to the target point to be considered near the target. In this case, the resulting path is closer to the optimal solution, effectively avoiding obstacles and extending precisely toward the target point, with higher path accuracy. However, the search time increases significantly, which may manifest as noticeably slower line drawing in the visualization and a later overall planning completion time. When the threshold is set to a larger value, the search process of path planning becomes faster, and the path extends more directly and broadly on the map. The algorithm can more quickly determine that a new node is close to the target point. However, this rapid search comes at the cost of reduced path accuracy. From the path planning results for $d=120$, it can be observed that while the path bypasses some obstacles, there are a few turning points where the path either crosses obstacles or comes too close to them, ultimately resulting in a less precise path.

Figure 8 shows the variation of path length with different threshold values. During the testing process, the threshold was incremented in steps of 5. The comparison reveals that the path length initially increases and then decreases as the threshold increases, with the minimum point occurring at a threshold of 65. Therefore, when the distance threshold between the new node and the target point is set to 65, it represents the optimal parameter for the path planning model.

Sensitivity analysis of the maximum number of iterations

In the path optimization process, the maximum number of iterations is a key hyperparameter that directly affects the algorithm’s convergence speed and computational performance. To evaluate the impact of the maximum number of iterations on the algorithm’s performance, we conducted a sensitivity analysis. By setting different maximum iteration counts, we aimed to find a reasonable range of iteration numbers that ensure the algorithm’s performance while improving computational efficiency. For the sensitivity analysis, we selected multiple different maximum iteration counts, with a range of 100–3,000 and an interval of 100, covering a spectrum of iteration numbers from small to large. Each experiment was conducted under the same initial conditions, and the path length and search time for each iteration were recorded to evaluate performance, as shown in Fig. 9.

According to the results of the sensitivity analysis, the path optimization algorithm reached the optimal balance point after 1,500 iterations. At this point, the path length converged to 1,058.67 m and remained stable, indicating that it was close to the theoretical optimal solution. Meanwhile, the search time increased linearly with the number of iterations, and at 1,500 iterations, the algorithm took 13.38 s. Further increasing the number of iterations, although the computation time for path planning continued to rise, the path length tended to stabilize. Therefore, 1,500 iterations is the optimal choice for this method in a strict sense.

Ablation study on the removal of algorithm modules

To comprehensively evaluate the actual contribution and interaction of each algorithm module in the proposed path planning method, we conducted ablation studies by removing the three core modules: the adaptive step size (ASS) optimization strategy, the KD-Tree fast search mechanism, and the cubic spline function (CSF) path optimization. First, in the case of removing the adaptive step size optimization strategy, a fixed step size of 20 was used, and the path planning algorithm was rerun. When removing the adaptive step size optimization strategy, to ensure the rationality of the experimental design, a fixed step size value was selected. This value was initially tuned through preliminary experiments and considered the sensitivity of the path planning algorithm to step size changes. Through experimental analysis of different step sizes, a step size of 20 was ultimately chosen as the fixed value. This value balanced the accuracy of path planning with computational efficiency. Under this step size, the algorithm exhibited stable performance, ensuring both path planning accuracy and maintaining high computational efficiency. Next, the KD-Tree fast search mechanism was removed, and a traditional traversal search method was used to find the nearest node. Finally, the cubic spline function path optimization module was removed, and no smoothing was applied to the generated raw path. The experimental results are shown in Table 4.

Figure 10 shows the path planning results for Scene 3 before and after removing the adaptive step size optimization strategy. The comparison reveals that when approaching the target point, the inability to dynamically adjust the step size leads to excessive path extension or deviation from the target. Fixed step sizes make fine adjustments difficult. After applying the adaptive step size optimization strategy, the search area is significantly reduced, effectively decreasing the search time required for path planning. Additionally, fine adjustments can be made when the path approaches obstacles, highlighting the critical role of the adaptive step size optimization strategy in improving the accuracy of path planning.

Figure 11 shows the variation in path search time under different iteration counts for Scene 2 and Scene 3 before and after removing the KD-Tree fast search mechanism. The comparison reveals that the quality of path planning remains largely unchanged before and after removal. However, after removing the KD-Tree fast search mechanism, the runtime required for the path planning algorithm increases significantly, especially in complex environments. As the map scale and the number of nodes increase, the search efficiency drops sharply. This indicates that the KD-Tree fast search mechanism plays an irreplaceable role in accelerating the search speed for the nearest node and enhancing the algorithm’s performance in complex scene.

Figure 12 shows the path planning results for Scene 3 before and after removing the cubic spline function path optimization. The comparison reveals that after removing the cubic spline function path optimization, the generated path exhibits more sharp turns, which is not only visually less ideal but may also lead to difficulties in motion control in practical applications, failing to meet the requirements for path smoothness. In contrast, the method incorporating cubic spline function path optimization generates a smoother and more continuous path, better aligning with the needs of practical applications.

Through the ablation studies above, it is clear that the adaptive step size optimization strategy, the KD-Tree fast search mechanism, and the cubic spline function path optimization each play an indispensable role in the proposed path planning method. These modules work in synergy, collectively enhancing the accuracy, algorithmic performance, and path quality of path planning, providing a more efficient and reliable path planning solution for practical applications.

Discussion on practical applications

In practical AGV applications, the quality of path planning directly impacts the AGV’s work efficiency, energy consumption, and operational safety. In complex environments such as large warehouses, traditional path planning algorithms like RRT, RRT*, and Informed RRT often suffer from optimization issues. These algorithms may lead to frequent turns or overly winding paths, which not only increase the average path length but also cause the AGV to consume more energy during operation. Our proposed improved algorithm enables the AGV to reach the target more quickly with a shorter path in the same environment, reducing unnecessary turns and significantly lowering energy consumption. Compared to traditional algorithms, the average path length is reduced by 164.33 m, and the average search time is reduced by 3.39 s, further improving logistics efficiency. Additionally, in scenarios with narrow passages or many obstacles, the improved algorithm optimizes the smoothness of path turns, reducing equipment wear caused by frequent turning or sudden stops, thus extending the lifespan of the equipment and lowering maintenance costs for the company. At the same time, we introduced an adaptive step size optimization strategy and a nearest neighbor fast search method, effectively avoiding blind search, allowing the AGV to plan more stable and reasonable paths, and better cope with complex and dynamic application environments.