Highly real-time path planning method for unmanned vehicles in dense static obstacle environments
Through the multi-module collaborative optimization path planning method, safe, close to optimal and kinematic feasible paths for unmanned vehicles in dense obstacle environments are generated, which solves the problems of insufficient speed, optimality and completeness in the prior art, and achieves efficient path planning effects.
Patent Information
- Application Number
- CN202310211546.0
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2023-03-07
- Publication Date
- 2025-08-19
- Estimated Expiration
- 2043-03-07
AI Technical Summary
The existing autonomous vehicle path planning methods are difficult to take into account the solution speed, optimality of result and completeness of result in dense obstacle scenarios, and cannot quickly generate safe, close to optimal and feasible paths in the kinematic sense.
Using the method of collaborative work of multiple modules, firstly, the path P1 that is strictly obstructed but not kinematically feasible is generated, and then a path P2 that is feasible but does not guarantee obstacle avoidance is generated through a pure tracking algorithm. The path is optimized using collision detection and node transition techniques to generate the final collision-free and kinematically feasible path P2new.
High real-time path planning is achieved in dense static obstacle environments. The generated paths are safe, close to optimal and kinematically feasible, and the solution success rate, average solution time and path length are better than existing methods.
Smart Images
Figure CN116242382B_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the technical field of unmanned vehicle path planning, and in particular to a high-real-time unmanned vehicle path planning method for use in a dense static obstacle environment. Background Art
[0002] Path planning is a key function of autonomous vehicles. Its purpose is to generate a path from a starting position (hereafter referred to as pose) to a predetermined ending position. This path should meet the vehicle's kinematic requirements and avoid all obstacles in the environment.
[0003] Dense obstacle scenarios refer to scenarios where a large number of obstacles are densely distributed within the workspace between the starting and ending positions. Unlike structured urban road scenarios, dense obstacle scenarios do not have road guide lines. Therefore, compared to the former, which only needs to consider obstacle avoidance and vehicle kinematic requirements, the path planning task in dense obstacle scenarios also needs to consider the optimality of the result homotopy category (i.e., whether the vehicle circumvents the obstacle to the left or right). In addition, dense obstacle scenarios often have a large number of irregular obstacles randomly distributed. See Figure 1 , Figure 1 The objects filled in medium gray are obstacles. Ensuring that the generated path avoids all obstacles and safely reaches the final position is a technical challenge, making path planning in scenes with dense obstacles very difficult.
[0004] Existing path planning methods for autonomous vehicles include three types of path planning methods: search-based, sampling-based, and optimization-based. However, when dealing with path planning tasks in scenarios with dense obstacles, they often cannot take into account the solution speed, optimality, and completeness of the results.
[0005] Therefore, it is necessary to propose a path planning method that can quickly plan a safe, near-optimal and kinematically feasible path in a dense obstacle environment. Summary of the Invention
[0006] The technical problem to be solved by the present invention is that, in view of the problem that existing autonomous driving vehicle path planning methods often cannot take into account the solution speed, result optimality and result completeness when dealing with path planning tasks in dense obstacle scenarios, a high-real-time unmanned vehicle path planning method for dense static obstacle environments is proposed.
[0007] This method for high-real-time unmanned vehicle path planning in a dense static obstacle environment includes the following steps:
[0008] Step 1: After the planning task begins, the execution module A obtains a path P1 that strictly avoids obstacles but is kinematically infeasible, and a path P2 that is kinematically feasible but does not guarantee obstacle avoidance, based on path P1.
[0009] Step 2: Perform a collision check on path P2. If the check passes, path P2 is considered a kinematically feasible and obstacle-avoiding final path. Outputting this path directly completes all tasks. If a collision is detected during the P2 check, module B is immediately executed: This module intercepts the collision portion of path P2 and calculates a corresponding set of discrete nodes on path P1, denoted as Ncol.
[0010] Step 3: Input the set of discrete nodes Ncol into module C. This module uses a collision-pushing method to continuously move the nodes in the set Ncol away from obstacles. The path formed by these pushed nodes is recorded as P1'. Module A then operates on P1' to obtain a new kinematically feasible path, recorded as P2'. Path P2' is then checked for collisions. If a collision occurs, the above operation is repeated until the resulting path P2' passes the collision check.
[0011] Step 4, execute module D: use path P1' to replace the segment at the same position on path P1 to obtain a new path, recorded as P1new; then obtain a new kinematically feasible path based on path P1new, recorded as P2new.
[0012] Furthermore, in step 1 module A: use the pure tracking algorithm to track the path P1 to obtain the feasible path P2 in the kinematic sense, assuming the starting posture S, the ending posture G, and the obstacle information w obs ,but:
[0013] P astar =AstarPathPlanning(S,G,w obs );
[0014] If P astar .size()! =0, then P1=LengthenPath(P astar ), P2 = PurePursuit (P1);
[0015] If P astar .size()!≠0, the algorithm fails.
[0016] Furthermore, module B is responsible for intercepting the collision area of the path P2 and calculating the corresponding area of path P1, that is, a set of a series of ordered discrete nodes on path P1. Specifically:
[0017] Since the pure tracking algorithm requires setting a preview point, which makes it impossible to reach the actual end point of the tracked path, it will not only intercept the collision area of path P2, but also extend the two end points of the actual collision part of path P2 by a certain distance before intercepting; if there is only one collision area on path P2, the extension-interception operation is directly performed; if there are multiple collision areas on path P2, these collision areas will be extended separately and then any two parts will be checked for intersection. If they intersect, the two areas will be merged and then intercepted; the collision area intercepted from path P2 is a set of ordered waypoints, which is denoted as Wc;
[0018] For each waypoint in Wc, find the node closest to it on path P1 in turn, and record the set of these nodes as Ncol. Since path P1 is a set of ordered nodes, each node on path P1 has its own unique serial number, recorded as index. Therefore, the set Ncol records not only the node's location information, but also the serial number information of the node on path P1.
[0019] When searching for the nearest node corresponding to a waypoint, if several waypoints correspond to the same node, since the node serial numbers are unique, duplicate serial numbers can be deleted from the set Ncol and sorted in ascending order, thereby ensuring that each collision area on path P2 can find a unique corresponding node sequence on path P1.
[0020] Module C is responsible for processing the node set Ncol obtained by Module B to ensure that the kinematically feasible path derived from this set is collision-free. Specifically, Module C uses a pure tracking algorithm to derive a kinematically feasible path P2' from the node set Ncol, performs collision detection on it, and lists all collision-prone waypoints on path P2' into the set Wcol. This collision information is then used to nudge the nodes in set Ncol away from obstacles, ensuring that the resulting path is collision-free.
[0021] The method of using collision information to push the nodes in the set Ncol away from obstacles is:
[0022] Determine the node to be moved: Take a point in the set Wcol, denoted as M, and find the point in the set Ncol that is closest to point M, denoted as Q. Point Q is the node we need to move.
[0023] Determine the direction of node Q's displacement: Split the vehicle projection at point M in two along the vehicle's longitudinal axis. The side that collides with the obstacle will be displaced toward the other side. If both sides collide simultaneously, the side with the greater collision severity will be displaced toward the other side. This gives the direction of node Q's displacement, which is the normal direction to the vehicle's longitudinal axis at point M.
[0024] Set the distance that node Q is moved to d, which is a configurable parameter and is set to 0.1m by default; move node Q according to the above direction and distance to obtain a new node Q1; repeat this operation for all nodes to obtain a new node set, namely the new path P1'; then use the pure tracking algorithm to track path P1' to generate a new feasible path P2' in the kinematic sense, and then check whether it collides; if there is no collision, output path P1' to the next module D; if there is a collision, repeat the above steps until path P2' does not collide or the algorithm fails after exceeding the set maximum number of iterations.
[0025] Furthermore, module D is responsible for replacing the fragment of path P1's original position with the path P1' obtained by module C, obtaining a complete new path P1new, and based on this, obtaining the final, complete, collision-free, and kinematically feasible path P2new. Module D specifically states: Path P1' is a collection of nodes. Although the collision and displacement operations change the position information of these nodes, their sequence numbers on the original path P1 are still retained. The replacement operation is completed by replacing the position of the corresponding sequence number node on the original path P1 according to this sequence number. Repeating the above operation for all nodes in path P1' yields a new path P1new. Tracking this path P1new using a pure tracking algorithm yields a new kinematically feasible path P2new.
[0026] Due to the potential error at the replacement boundary points caused by the replacement operation, P2new may still experience a slight collision in extremely rare cases. In this case, the steps of modules B, C, and D can be repeated until the collision check passes. If the specified time is exceeded, the algorithm is considered to have failed and will be exited.
[0027] The implementation of the embodiments of the present invention has the following beneficial effects:
[0028] The present invention discloses a high-real-time unmanned vehicle path planning method for dense static obstacle environments. The method is suitable for use by unmanned vehicles in dense static obstacle environments and can provide unmanned vehicles with a planned path that is safe, near-optimal, and kinematically feasible. The performance in three dimensions, namely, solution success rate, average solution time, and average path length, is significantly superior to similar mainstream algorithms on the market. BRIEF DESCRIPTION OF THE DRAWINGS
[0029] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.
[0030] Figure 1 Schematic diagram of the path planning task for an autonomous vehicle in a dense obstacle scenario;
[0031] Figure 2 This is a schematic diagram of the overall path planning solution provided by the present invention in a dense obstacle scenario;
[0032] Figure 3 Schematic diagram of the node moving direction;
[0033] Figure 4 This is a schematic diagram of the final node movement. DETAILED DESCRIPTION
[0034] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making any creative efforts shall fall within the scope of protection of the present invention.
[0035] See Figure 2 , Figure 2 This is a schematic diagram of the overall path planning solution for dense obstacle scenarios provided by the present invention. This method for high-real-time unmanned vehicle path planning in dense static obstacle environments includes the following steps (assuming that all environmental information is fully known, i.e., the positions and sizes of all obstacles are known and that these obstacles are stationary):
[0036] Step 1: After the planning task begins, Module A determines a path P1 that strictly avoids obstacles but is kinematically infeasible, and a path P2 based on P1 that is kinematically feasible but does not guarantee obstacle avoidance. The path here is actually composed of a series of ordered discrete points; for ease of description, we will strictly distinguish between the two concepts below: discrete points on a kinematically infeasible path that avoids obstacles are called "nodes," and discrete points on a kinematically feasible path that does not guarantee obstacle avoidance are called "waypoints."
[0037] Module A: When faced with numerous obstacles, the A* algorithm, due to its simplicity, speed, probabilistic completeness, and optimal resolution, has become the mainstream path planning algorithm. While the path it generates is not smooth and may not meet vehicle dynamics requirements, it can provide a reasonable reference path. In fact, if all obstacles are puffed out by half the vehicle's width, the path generated by the A* algorithm is effectively a road centerline connecting the start and end points, with a width of one vehicle. Therefore, if the obstacles are puffed outward by 1.5 meters, a virtual road will be formed that is 3 meters wide. This ensures that the path generated by the A* algorithm provides a reasonable homotopy classification for the vehicle in most cases. This results in a path P1 that strictly avoids obstacles but is kinematically infeasible. This path provides a rough idea of which obstacles should be circumvented and from which direction.
[0038] The pure tracking algorithm, a classic geometric tracking algorithm, can output a kinematically feasible path suitable for vehicle travel by tracking a kinematically infeasible path. Furthermore, because this algorithm has no computational degrees of freedom, the entire computation process is extremely fast (a single calculation takes less than 1ms), making it highly real-time. Therefore, the pure tracking algorithm is used to track path P1 to obtain the kinematically feasible path P2. It is worth noting that because the pure tracking algorithm requires a pre-aiming point, its output path cannot reach the endpoint of the tracked path. Therefore, path P1 must be extended from the endpoint along a given ending posture for a certain distance before being tracked using the pure tracking algorithm. This results in a kinematically feasible path P2 connecting the starting and ending points. However, because the pure tracking algorithm lacks internal collision avoidance constraints, it cannot guarantee that path P2 will strictly avoid obstacles. Therefore, if path P2 encounters a collision, subsequent modules will be required to handle this.
[0039] The specific algorithm is: Use the pure tracking algorithm to track the path P1 to obtain the feasible path P2 in the kinematic sense, set the starting posture S, the ending posture G, and the obstacle information w obs ,but:
[0040] P astar =AstarPathPlanning(S,G,w obs );
[0041] If P astar .size()! =0, then P1=LengthenPath(P astar ), P2 = PurePursuit (P1);
[0042] If P astar .size()!≠0, the algorithm fails.
[0043] Step 2: Perform a collision check on path P2. If the check passes, path P2 is the final path that is kinematically feasible and strictly avoids obstacles. Simply outputting it completes all tasks. If a collision is detected during the check on P2, module B is immediately executed: This module intercepts the collision portion of path P2 and calculates a corresponding series of discrete node sets on path P1, denoted as Ncol.
[0044] Specifically, module B is as follows: Since the pure tracking algorithm requires setting a preview point, which makes it impossible to reach the actual end point of the tracked path, it will not only intercept the collision area of path P2, but also extend the two end points of the actual collision part of path P2 by a certain distance before intercepting, so that the subsequent module C can reproduce the actual situation of the collision at that location; if there is only one collision area on path P2, the extension-interception operation is directly performed; if there are multiple collision areas on path P2, these collision areas will be extended separately and then any two parts will be checked for intersection. If there is intersection, the two areas will be merged and then intercepted, so as to prevent repeated interception operations on two collision areas that are very close to each other, thereby affecting the efficiency of the overall algorithm.
[0045] The collision region intercepted from path P2 is a set of ordered waypoints, denoted as Wc. For each waypoint in Wc, the node closest to it is found on path P1, and the set of these nodes is denoted as Ncol. Since path P1 is a set of ordered nodes, each node on path P1 has a unique serial number, denoted as index. Therefore, the set Ncol records not only the node's location information, but also the node's serial number information on path P1.
[0046] When searching for the nearest node corresponding to a waypoint, if several waypoints correspond to the same node, since the node serial numbers are unique, duplicate serial numbers can be deleted from the set Ncol and sorted in ascending order, thereby ensuring that each collision area on path P2 can find a unique corresponding node sequence on path P1.
[0047] Finally, it's worth noting that module B only intercepts the collision portion of path P2 for processing because the time required to perform collision detection on a path is proportional to its length. Since module C may subsequently perform a large number of collision detection operations, intercepting the collision here significantly reduces the overall algorithm calculation time.
[0048] Step 3. Input the set Ncol of these discrete nodes into module C: This module uses the collision-pushing method to make these nodes in the set Ncol continuously move away from the obstacles, and the path formed by these new nodes after pushing is recorded as P1'; then use module A to operate on P1' to obtain a new feasible path in the kinematic sense, recorded as P2'; then perform a collision check on the path P2'. If a collision occurs, repeat the above operation until the obtained path P2' can pass the collision check.
[0049] Module C specifically uses a pure tracking algorithm to obtain a kinematically feasible path P2' based on the node set Ncol, performs collision detection on it, and lists all collision points on the path P2' into the set Wcol; using this collision information, it pushes these nodes in the set Ncol away from obstacles so that the path obtained by tracking again does not collide.
[0050] The method of using collision information to push the nodes in the set Ncol away from obstacles is:
[0051] Determine the node to be moved: Take a point in the set Wcol, denoted as M, and find the point in the set Ncol that is closest to point M, denoted as Q. Point Q is the node we need to move.
[0052] Determine the direction of node Q's movement: Divide the vehicle projection at point M into two along the longitudinal axis of the vehicle. The side that collides with the obstacle will move in the direction of the other side. If both sides collide at the same time, the side with the greater collision severity will move in the direction of the other side. Figure 3 , Figure 3 is a schematic diagram of the node displacement direction, from which the displacement direction of node Q is obtained, which is the normal direction of the longitudinal axis of the vehicle at point M;
[0053] Set the distance that node Q moves to d. This distance is a configurable parameter and is set to 0.1m by default. Figure 4 , Figure 4 Figure 2 is a schematic diagram of the final node movement. Node Q is moved according to the above direction and distance to obtain a new node Q1. Repeat this operation for all nodes to obtain a new node set, namely the new path P1'. Then, a pure tracking algorithm is used to track path P1' to generate a new kinematically feasible path P2', and then check whether it collides. If there is no collision, path P1' is output to the next module D. If there is a collision, the above steps are repeated until path P2' does not collide or the algorithm fails after exceeding the set maximum number of iterations.
[0054] Step 4, execute module D: use path P1' to replace the segment at the same position on path P1 to obtain a new path, recorded as P1new; then obtain a new kinematically feasible path based on path P1new, recorded as P2new.
[0055] Module D is specifically as follows: path P1' is a collection of a series of nodes. Although the collision and displacement operation changes the position information of these nodes, their sequence number information on the original path P1 is still retained; the position of the corresponding sequence number node on the original path P1 is replaced according to the sequence number to complete the replacement operation; repeating the above operation for all nodes in path P1' can obtain a new path P1new; using a pure tracking algorithm to track the path P1new, a new feasible path P2new in the kinematic sense can be obtained.
[0056] Due to the potential error at the replacement boundary points caused by the replacement operation, P2new may still experience a slight collision in extremely rare cases. In this case, the steps of modules B, C, and D can be repeated until the collision check passes. If the specified time is exceeded, the algorithm is considered to have failed and will be exited.
[0057] This technical solution can quickly generate collision-free, kinematically feasible paths in cluttered environments, and at the same time has the advantages of high success rate and near-optimality.
[0058] To objectively evaluate the algorithm's capabilities, we conducted comparative experiments with the popular HybridA* and Cl-RRT* path planning algorithms. Simulations were run on a computer with an AMD Core Ryzen 5 4600H processor and 16.0GB of RAM, and the algorithms were implemented in Python. We randomly generated 1,000 test maps to evaluate the performance of the proposed path planning algorithm. Each map was 100m × 100m in size and contained 100 randomly placed irregular polygonal obstacles. The polygonal obstacles had 4 to 7 vertices, and each side ranged in length from 0.7m to 7m. The vehicle's starting and ending positions were [10m, 10m] and [90m, 90m], respectively, with the starting and ending directions both being π / 4. We evaluated the algorithm's performance using three metrics: success rate, average computational time for planning a path, and average mileage. Furthermore, if the algorithm took longer than 150s to solve, it was considered a failure. Due to the randomness of the Cl-RRT* algorithm results, its performance will be obtained by running each case 10 times and calculating the average value.
[0059] Table 1 summarizes the performance of these three algorithms in simulation experiments. As can be seen from the table, this technical solution significantly outperforms similar mainstream algorithms on the market, such as HybridA* and Cl-RRT* path planning, in terms of solution success rate, average solution time, and average path length.
[0060] Table 1 Comparison of algorithm test results
[0061]
[0062] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention should be included in the scope of protection of the present invention.
Claims
1. A high-real-time unmanned vehicle path planning method for dense static obstacle environments, characterized in that: The following steps are involved: Step 1: After the planning task begins, the execution module A obtains a path P1 that strictly avoids obstacles but is kinematically infeasible, and a path P2 that is kinematically feasible but does not guarantee obstacle avoidance, based on path P1. Step 2: Perform a collision check on path P2. If the check passes, path P2 is considered a kinematically feasible and obstacle-avoiding final path. Outputting this path directly completes all tasks. If a collision is detected during the P2 check, module B is immediately executed: This module intercepts the collision portion of path P2 and calculates a corresponding set of discrete nodes on path P1, denoted as Ncol. Step 3: Input the set of discrete nodes Ncol into module C. This module uses a collision-pushing method to continuously move the nodes in the set Ncol away from obstacles. The path formed by these pushed nodes is recorded as P1'. Module A then operates on P1' to obtain a new kinematically feasible path, recorded as P2'. Path P2' is then checked for collisions. If a collision occurs, the above operation is repeated until the resulting path P2' passes the collision check. Step 4: Execute module D: Replace the segments at the same position on path P1 with path P1' to obtain a new path, denoted as P1new; then, obtain a new kinematically feasible path based on path P1new, denoted as P2new; The module A is: using a pure tracking algorithm to track the path P1 to obtain a feasible path P2 in the kinematic sense, assuming the starting posture S, the ending posture G, and the obstacle information w obs ,but: P astar =AstarPathPlanning(S,G,w obs ); If P astar .size()! =0, then P1=LengthenPath(P astar ), P2 = PurePursuit (P1); If P astar .size()!≠0, the algorithm fails.
2. The high-real-time unmanned vehicle path planning method for dense static obstacle environments according to claim 1 is characterized in that: Module B in step 2 is specifically: Since the pure tracking algorithm requires setting a preview point, which makes it impossible to reach the actual end point of the tracked path, it will not only intercept the collision area of path P2, but also extend the two end points of the actual collision part of path P2 by a certain distance before intercepting; if there is only one collision area on path P2, the extension-interception operation is directly performed; if there are multiple collision areas on path P2, these collision areas will be extended separately and then any two parts will be checked for intersection. If they intersect, the two areas will be merged and then intercepted; the collision area intercepted from path P2 is a set of ordered waypoints, which is denoted as Wc; For each waypoint in Wc, find the node closest to it on path P1 in turn, and record the set of these nodes as Ncol. Since path P1 is a set of ordered nodes, each node on path P1 has its own unique serial number, recorded as index. Therefore, the set Ncol records not only the node's location information, but also the serial number information of the node on path P1. When searching for the nearest node corresponding to a waypoint, if several waypoints correspond to the same node, since the node serial numbers are unique, duplicate serial numbers can be deleted from the set Ncol and sorted in ascending order, thereby ensuring that each collision area on path P2 can find a unique corresponding node sequence on path P1.
3. The high-real-time unmanned vehicle path planning method for dense static obstacle environments according to claim 1 is characterized in that: Module C in step three specifically performs the following steps: using a pure tracking algorithm to obtain a kinematically feasible path P2' based on the node set Ncol, performing collision detection on the path, and listing all collision points on the path P2' into the set Wcol; using this collision information to push the nodes in the set Ncol away from obstacles, so that the path obtained by re-tracking does not collide.
4. The high-real-time unmanned vehicle path planning method for dense static obstacle environments according to claim 3 is characterized in that: The method of using collision information to push the nodes in the set Ncol away from obstacles is: Determine the node to be moved: Take a point in the set Wcol, denoted as M, and find the point in the set Ncol that is closest to point M, denoted as Q. Point Q is the node we need to move. Determine the direction of node Q's displacement: Split the vehicle projection at point M in two along the vehicle's longitudinal axis. The side that collides with the obstacle will be displaced toward the other side. If both sides collide simultaneously, the side with the greater collision severity will be displaced toward the other side. This gives the direction of node Q's displacement, which is the normal direction to the vehicle's longitudinal axis at point M. Set the distance that node Q is moved to d, which is a configurable parameter and is set to 0.1m by default; move node Q according to the above direction and distance to obtain a new node Q1; repeat this operation for all nodes to obtain a new node set, namely the new path P1'; then use the pure tracking algorithm to track path P1' to generate a new feasible path P2' in the kinematic sense, and then check whether it collides; if there is no collision, output path P1' to the next module D; if there is a collision, repeat the above steps until path P2' does not collide or the algorithm fails after exceeding the set maximum number of iterations.
5. The high-real-time unmanned vehicle path planning method for dense static obstacle environments according to claim 1 is characterized in that: Module D in step 4 is specifically as follows: path P1' is a collection of a series of nodes. Although the collision and displacement operation changes the position information of these nodes, their sequence number information on the original path P1 is still retained; the position of the corresponding sequence number node on the original path P1 is replaced according to the sequence number to complete the replacement operation; repeating the above operation for all nodes in path P1' can obtain a new path P1new; using a pure tracking algorithm to track the path P1new can obtain a new feasible path P2new in the kinematic sense.
6. The high-real-time unmanned vehicle path planning method for dense static obstacle environments according to claim 5 is characterized in that: Due to the potential error at the replacement boundary points caused by the replacement operation, P2new may still experience a slight collision in extremely rare cases. In this case, the steps of modules B, C, and D can be repeated until the collision check passes. If the specified time is exceeded, the algorithm is considered to have failed and will be exited.