I Introduction
In this work, we study the problem of finding minimaltime collisionfree paths for curvatureconstrained systems with variable speed. Curvature constraints are prevalent in a variety of systems (see, e.g., [12, 28, 20, 6]). Unfortunately, determining whether a collisionfree curvatureconstrained path exists is NPhard even for a planar system [1]. As a result, this continuous problem can be discretized into a graph data structure using samplingbased [29] or searchbased approaches [24], which is then queried to obtain a discrete path representing a curvatureconstrained solution in the continuous space. The graph’s vertices correspond to robot configurations (i.e., dimensional points that uniquely describe the robot’s position and orientation) and edges correspond to local motions taken by the robot.
Interestingly, the computational bottleneck in these search algorithms is a frequent computation of local timeoptimal transitions between neighboring vertices, obtained using numerical optimization. Our key insight, depicted in Fig. 1, is that computing all the timeoptimal transitions is both (i) computationally expensive and (ii) unnecessary for many problem instances. We introduce a novel algorithmic framework, which we call T*, that allows finding boundedsuboptimal solutions while reducing planning times by orders of magnitude compared to the stateoftheart.
Our framework consists of three algorithmic components. The first component assumes that we have an efficienttocompute lower bound on the cost of the optimal transition between two configurations. In Sec. VI, we demonstrate two such bounds—when the environment does not and does contain dynamics such as wind currents. The second algorithmic component is the A*based search algorithm [17] that uses these lower bounds on optimal transitions, together with a userprovided approximation factor , to choose which edges to consider. Roughly speaking, the search attempts to use only transitions for which the true (computationally expensive) cost was computed while guaranteeing the bound on the quality of the solution obtained. Finally, the third component is a heuristic approach to precompute a small set of transitions that are likely to be used in an optimal path.
Using efficienttocompute lower bounds on the cost of local transitions is a common technique to speed up motionplanning algorithms (see, e.g., [2, 10, 3, 21, 15]). These are used to minimize the computation time taken to compute the cost of an edge or transition, also known as an edge evaluation. Typically, edge evaluation corresponds to computing if a robot intersects an obstacle while performing some local motion (also known as collision detection [14]). Thus, the computationally expensive operation of edge evaluation is applied to each edge individually. Indeed, it can be shown that under some mild assumptions, these approaches allow minimizing the number of edges evaluated [7].
In our case, we plan in a discretized space; thus, the setting is somewhat different. There is a fixed set of transitions that can be taken from any given configuration. Since these transitions are computationally expensive to compute, it is natural to try and reuse transitions that have already been computed. The challenge is how this should be done while ensuring that the cost of the path found is within a given multiplicative bound of the cost of an optimal path.
As we demonstrate in simulation (Sec. VI), our planning framework allows to compute only a small fraction of transitions, which, in turn, allows us to reduce the runtime by several orders of magnitude compared to the stateoftheart, especially in dynamic conditions.
Ii Related Work
We now continue to review related work on planning for minimumtime planar curvatureconstrained systems. When the system is constrained to travel at a single speed, an optimal path connecting two configurations (i.e., two planar locations, each associated with its angular heading) can be computed analytically [4]. In this setting, an optimal path, also known as Dubins path, is one of six types: RSR, RSL, LSR, LSL, RLR, and LRL, where R and L refer to right and left turns, respectively, and S refers to going straight. As the system travels at a single speed, the shortest and the timeoptimal paths are identical.
The kinematic model considered in this work is the setting where the system can travel at some range of speeds but with unbounded acceleration (i.e., transitioning between low and highspeed can be done instantaneously). It is not hard to see that, in such a setting, the shortest path is attained by computing the optimal Dubins path, assuming that the system travels at the minimum speed (as the system can travel using the smallest turning radius possible and can thus better maneuver). Computing the timeoptimal path requires alternating between lowspeed (to allow for tighter turns) and highspeed motions (to allow for faster progress).
Wolek et al. [27] showed that it is sufficient to consider only the two extreme speeds and identified a sufficient set of 34 candidate paths (in contrast to the sixcandidate paths when the system travels at a single speed). Each candidate path contains circular arcs and straightline segments on which the vehicle can travel at either of the two extreme speeds. However, in contrast to Dubins paths, which can be computed analytically, computing these timeoptimal paths for a variablespeed system requires a numerical optimization that is (i) much more computationally expensive and (ii) may return locally optimal solutions (and not globally optimal ones). Kučerová et al. [13] showed an efficient heuristic approach to find highquality paths when considering time as the cost function by using multiple turning radii. However, there is no guarantee regarding the quality of these paths.
For each model mentioned above, motionplanning algorithms that account for environmental obstacles were introduced. These include both samplingbased approaches such as the work by Wilson et al. [26], searchbased methods such as the work by Song et al. [22], and hybrid methods that borrow ideas from both motionplanning disciplines [19]. Of specific interest to the presented work is T* [22], a timeoptimal riskaware motionplanning algorithm that obtains a timeoptimal solution but requires a timeconsuming preprocessing phase. As our work builds upon the algorithmic foundation of T*, we describe it in Sec. IV. Following T*, Wilson et al. [25] developed a fast motionplanning algorithm that uses Dubins paths of various speeds to reduce the computational effort and runtime of T*. For the settings evaluated, the costs of solutions obtained by this algorithm are nearoptimal, but there are no guarantees regarding the quality of solutions.
The aforementioned kinematic model can be extended to account for external dynamic changes such as wind or ocean currents. For such systems, a minimumtime path can be computed similarly to the setting where no wind exists [23]. However, only two candidate path types have analytic solutions (RSR and LSL). Mittal et al. [16] used those two types to compute a path between two vehicle poses under ocean currents. These kinematic models were used not only in the context of singlegoal motion planning problems but also in the settings where the objective is to reach multiple goals [5] and further extended to account for some notion of rewards [18].
Iii Problem Statement
Our problem formulation follows Song et al. [22]. Specifically, we assume a variablespeed curvatureconstrained planar robotic system with unbounded acceleration. The system’s dynamics can be described by
(1) 
Here, is the robot’s placement and orientation, is the robot’s speed (which is considered as a control input) and is the second control input dictating the system’s turning rate via maximal lateral acceleration that is determined for the specific system^{1}^{1}1For example, for fixedwing vehicles, where is the gravitational acceleration and the maximum allowed bang angle. as
(2) 
The speed is limited by some minimum and maximum values denoted by and , respectively. W.l.o.g., we assume that . Thus, the system is constrained to travel between two extreme radii:
(3) 
We assume that the continuous workspace is discretized into a grid according to a predefined resolution. Each cell can be categorized as free or forbidden corresponding to locations that the system can and cannot occupy, respectively. In addition, we assume that every robot motion starts and ends at the center of a cell. Specifically, at each step, the robot transitions to one of its eight neighbors and with one of eight possible orientations.
A path is a sequence of configurations where the transition between them obeys the system’s dynamics and constraints (Eq. 1). It is said to be collision free if it only occupies free cells. The cost of a path is the stepwise cost of the transitions between any consecutive configurations in . It can be computed using the system velocity along . Namely,
(4) 
where refers to the speed along the path segment .
Given start and goal configurations , a collisionfree path is said to be optimal if it (i) starts at and ends at ; and (ii) there is no path connecting and such that . Similarly, it is said to be boundedsuboptimal for some approximation factor if it (i) starts at and ends at ; and (ii) for any path connecting and , .
While previous works (see, e.g., [22]) were concerned with finding optimal paths, in this work, we are interested in finding boundedsuboptimal paths for a userprovided approximation factor . As we will see, the extra flexibility obtained by finding boundedsuboptimal paths allows us to reduce running times by orders of magnitude with little compromise on the path quality in practice.
Iv Algorithmic Background
As both A* [17] and T* [22] serve as the algorithmic foundation of our work, we provide a brief description of these two algorithms.
Iva A* Astar epsilon)
A* (also known as Focal search) [17] is a boundedsuboptimal search algorithm based on the celebrated A* algorithm [9]. Like A*, it searches a graph by continuously expanding nodes, starting from the start node until the goal node is reached. To ensure optimality, A* orders nodes in a priority list called Open. Nodes in the Open list are ordered according to their value that is the sum of the cost to reach the node from the source (also known as the costtocome or value and denoted by for a node
) added to a conservative estimate of the cost to reach the goal (also known as the costtogo or
value and denoted by for a node ). Namely for a node , its value is(5) 
Unlike A*, A* also uses a socalled Focal list containing all nodes from the Open list whose values are no larger than times the smallest value in the Open list. It can be shown that expanding any sequence of nodes from the Focal list ensures that the cost of the final solution will indeed be bounded by a factor of when compared to the cost of the optimal solution.
IvB T* (Tstar)
T* [22] builds on the approach by Wolek et al. [27] that allows finding an optimal^{2}^{2}2 To be precise, the solutions computed are only an approximation of the timeoptimal solutions since the computation is based on numerical optimizations, which may not converge to a global optimum. Thus, the optimality of T* and the boundedsuboptimality of T* is only with respect to (w.r.t.) the quality of the localoptimization. solution for the timeoptimal transition between any two configurations in an obstaclefree space. These transitions are used to compute all possible motions for an agent in a discretized eightconnected grid. In this space, there is a finite set of possible transition types. For example, a transition can be moving from configuration to configuration , which corresponds to moving diagonally in the NE direction while changing the system’s heading.
To this end, there are a total of possible transitions (eight possible start and target orientations and eight neighboring cells). However, after accounting for symmetry and rotation, there are only 68 unique transitions.
After precomputing all possible transitions, an A*like search is used to find a minimalcost path. In their original work, Song et al. [22] consider both minimaltime paths and a costfunction that balances the time and the risk of colliding with an obstacle. However, we consider only minimumtime paths in this work and refer to T* as the search algorithm that optimizes this criterion.
It is important to note that in many settings it is not possible to precompute all transitions in an offline phase. This is because optimizationrelated parameters might be available only when a query is provided. For example, in the presence of wind conditions, which affect the system’s dynamics and hence the transitions’ computation, wind parameters are only available to the planner when a query is provided. For further details, see Sec. VI.
Interestingly, after extensive empirical evaluation, we noticed that: (i) precomputing all possible transitions last two orders of magnitude more than the A*like search; (ii) only a small fraction of all possible timeoptimal transitions are part of an optimal path found by T*; and (iii) Dubins path computed using the minimal speed (whose cost is a lower bound on the length of the timeoptimal path) is often in the same homotopy class as the optimal path and shares a significant portion of its transitions. These observations are key to our algorithmic framework described in the following section.
V Algorithmic framework—T*sec:tstareps
Va Preliminaries
Let denote a set of possible transitions. By a slight abuse of notation, we assume that we have access to two functions and . The first, which is expensivetocompute, corresponds to evaluating the true cost of the transition according to Eq. 4. The second, which is fasttocompute, corresponds to evaluating a lower bound on the transition cost. Namely, . Once the cost of a transition is evaluated using , the value is stored in a cachelike data structure for later use. Thus, there is no need to compute it again when evaluating the same transition later.
To this end, let be an indicator function corresponding to the cases where the cost of a transition (i) has not been evaluated using , i.e., or (ii) has been evaluated using , i.e., . We start our algorithm with the setting that .^{3}^{3}3The reason we chose to define in this manner is that we start with for all nodes and order nodes lexicographically in the Focal list where lower means better.
VB Algorithmic Description
12
12
12
12
12
12
12
12
12
12
12
Our algorithmic framework, summarized in Alg. 1, consists of the following two main steps.

Heuristically computing the true cost for a small set of transitions.

Finding a boundedsuboptimal solution while trying to minimize the number of calls to .
In the first step S1 (lines LABEL:tstarepsshortest–LABEL:tstarepsupdate_kappa), we start by finding the shortestcollisionfree Dubins path (line LABEL:tstarepsshortest) from to that uses the minimum speed . For every transition taken along this path, we compute its true cost , cache it, and set (lines LABEL:tstarepsfor_each_transition–LABEL:tstarepsupdate_kappa).
In the second step S2 (lines LABEL:tstarepsastareps–LABEL:tstarepsset_g), we run an A*like search to find a boundedsuboptimal path from to given some approximation factor . We base our search algorithm on A* because we can use it to heuristically guide the search to expand nodes for which the incoming timeoptimal transition has already been computed.
Formally, each node considered by the search is associated with a parent node except for the start node associated with , which has no parent. In addition, each node stores the timeoptimal transition used to get from to . When expanding a node (namely, computing successor nodes and inserting them into the OPEN list), the true cost of the timeoptimal transition leading to is computed. However, the cost used to reach a successor node via transition is (i) if and (ii) if . Note that for some nodes in the Open list, the true cost of the timeoptimal transition associated with them may not have been computed. However, for all expanded nodes, the true cost of the incoming timeoptimal transition is computed at some point.
To this end, if we set to be the costtocome (value) of the start node, then the costtocome of any other node in the Open list is
(6) 
The value of the node (denoted by and used to prioritize nodes in the Open list) is defined in Eq. 5. can be any admissible estimate of the cost to reach the goal. In our setting, we use the length of the minimum speed Dubins path divided by the vehicle’s maximum speed.
Recall (Sec. IV) that A* uses a Focal list that contains all nodes whose value is at most times the value of the minimalcost node in the Open list. In our setting, nodes in Focal are lexicographically sorted using the following key (from low to high):
(7) 
Thus, any node for which (i.e., the true cost of the transition leading to has been computed) is always prioritized before any node for which (i.e., the true cost of the transition leading to has not been computed), regardless of their respective values. Among all nodes with identical values of , nodes with smaller values are prioritized. Once a node is chosen for expansion, the true cost of is computed if it has not been computed beforehand. Finally, a path is found once a node associated with the goal configuration is removed from the Open list.
Following the theoretic properties of A* [17] and using the fact that we have the following Corollary.
Corollary 1
Let and be some function that bounds from below the true cost of any timeoptimal transition. T*, using is boundedsuboptimal with an approximation factor of .
Vi Evaluation
In this section, we report on empirical evaluation of our approach in a simulated environment inspired by Song et al. [22]. We start (Sec. VIA) by evaluating our heuristic approach for computing the true cost for a small set of transitions (step S1). Then we continue (Sec. VIB) to demonstrate how the lower bound needs to be both informative (i.e., as close as possible to the real cost ) and computationally cheaptocompute (as its main purpose is to save computation time) by evaluating several different lower bounds that balance these two traits. We then move to compare our motionplanning approach with T* in static environmental conditions (Sec. VIC), i.e., when the system dynamics are known before the query is provided and are independent of the specific location at which the robot resides, and in dynamic environmental conditions such as when wind currents exist (Sec. VID). Finally, we briefly discuss and qualitatively compare T* with alternative approaches to find paths that attempt to minimize the execution time (Sec. VIE).
All experiments were run on a Intel Core i9 processor with of memory. Benchmarks, system parameters, and C++ implementation of all the algorithms used in our work are publicly available^{4}^{4}4 https://github.com/CRLTechnion/tstarepsilon.. Throughout Sec. VIA–VIC, we test the performance of our algorithm across randomly generated scenarios of cells and using
, where for a given scenario, each cell has a probability of
of being blocked, and the start and goal configurations are chosen uniformly at random while ensuring that a solution exists. When reporting algorithmic attributes, e.g., solution cost or runtime, the values represent the average across thescenarios. In some cases, we also report confidence intervals that include two standard deviations from the mean. In Sec.
VID, we provide additional information on the experiment setup.Via Evaluating the Efficacy of step S1
To evaluate the efficacy of the step S1, wherein we provide a heuristic approach for computing the true cost for a small set of transitions, we report the number of calls to by T* as a function of the approximation factor with and without this initial step (Fig. 2).
Observe that for values of larger than , using S1 allows reducing the average number of calls to by roughly . Moreover, in this case, for large approximation factors, the average calls to converges to the number of transitions in . When the step S1 is not invoked, T* is not “bootstrapped” with a good set of precomputed timeoptimal and thus evaluates unnecessary transitions.
ViB Computing Lower Bounds—Balancing Computation Time with Informative Lower Bounds
Recall that in Sec. LABEL:sec:tstareps, we assumed that we have access to —an efficienttocompute tight lower bound on , the true cost of the timeoptimal transition. However, there is an inherent tradeoff between how informative a lower bound is (which immediately corresponds to how accurately it can guide the search) and its computation time (which can negate the effectiveness of the lower bound).
We evaluated T* using three different lower bounds that demonstrate this behavior: (i) Euclidean distance divided by ; (ii) length of minimumspeed Dubins path divided by ; and (iii) length of minimumspeed Dubins path divided by while accounting for environment obstacles. Note that all lower bounds are divided by , thus always underestimating the true cost of a transition. In addition, they are ordered from low to high according to their computation time and how informative they are.
We compare (Fig. 3) the three lower bounds w.r.t. the number of timeoptimal transitions computed by T* and its running time. As expected, the Euclidean distance is the leastinformative lower bound, thus resulting in the maximal number of timeoptimal transitions computed for all values of . Moreover, even though it is efficienttocompute, it does a poor job in guiding the search, and thus the runtime is high. Computing Dubins path while accounting for obstacles is more informative but also more expensivetocompute. It does result in the smallest number of calls to but has longer running times when compared to using Dubins paths that do not account for obstacles. The latter also has a comparable number of calls to . Thus, we use Dubins paths without obstacles as the lower bound in the rest of the evaluation.
ViC Motion Planning in Static Environmental Conditions
We compare T* with T* in static environmental conditions, i.e., where the system dynamics are invariant to the robot’s placement and orientation in the scenario. As we can see in Fig. (c)c, computing timeoptimal transitions dominate the running time of all algorithms. If the system dynamics are known in advance, these can be precomputed in an offline step by T*, and it outperforms T* for all by a factor of between and . However, if we account for this preprocessing time, T* dramatically reduce the run time by a factor ranging between and . It is worth noting that in either case, T* finds a solution with an average cost that is much lower than the guaranteed suboptimality bound.
ViD Motion Planning in Dynamic Environmental Conditions
In the previous section, we considered static environmental conditions and showed that using an approximation factor allows reducing T*’s planning times dramatically. However, if the system’s dynamics are known in advance, T* may perform all its computationallyexpensive operations in a preprocessing stage. In contrast, this is not the case when the system’s dynamics are not known in advance. It can be due to changes in the maximal speed that the system can take (due to, e.g., payload changes of the system or regulatory changes happening just before a query is received) or due to dynamic environmental conditions such as wind currents whose magnitude and direction is known only when a query is received. We use the latter case to demonstrate the efficacy of T*. In particular, we assume that the magnitude of wind currents is uniform across a given scenario.
It is worth noting that this dynamic setting, analyzed by Techy and Woolsey [23], can be seen as a generalization of the setting described in Sec. III and by Mittal et al. [16]. To account for this moreinvolved dynamic setting, we first note that one cannot use rotation and symmetry between transitions to reduce the total amount of unique transitions. Thus, in this setting, the total number of timeoptimal transitions is 512. Moreover, this requires an adaptation of how timeoptimal transitions are computed (see the Appendix for a description of the new model). This adaptation, based on the code for computing timeoptimal transitions [27], is publicly available^{5}^{5}5https://github.com/CRLTechnion/VariablespeedDubinswithwind. The second notable change is that computing lower bounds (namely, when calling , requires some care, and the modifications are detailed in the Appendix.
For dynamic environmental conditions, we used the same randomly generated scenarios as described earlier. For each such scenario, we generated instances with varying wind and minimum velocity values. In particular, we sampled wind conditions from and minimum velocity values . In total, we ran experiments and the averaged results appear in Fig. 5. The most computationally demanding component in both T* and T* is still computing the timeoptimal transitions, which requires two orders of magnitude more time than any other algorithmic component. However, we observe that the approximation factor allows for a dramatic reduction of the running time with little compromise on the quality of the solution. For example, as it can be seen in Fig (c)c, using , T* guarantees a solution whose cost is at most twice the cost of the optimal solution, but returns a path whose average cost is no more than . It is done while obtaining a speedup in run time by an average factor of . In general, as depicted in Fig. (c)c, increasing results in a dramatic runningtime improvement at the cost of slightly lower solution quality.
ViE Discussion—Alternative Approaches
Wilson et al. [25] reduced computational effort by allowing the system to follow Dubins paths but using several radii, and evaluated this approach when using three different radii. This heuristic approach reduces runtime, produces nearoptimal solutions but with no guarantees regarding their quality. From our comparison of T* and Wilson’s model in static environments, we found that running times are faster by several orders of magnitude, but path costs are larger by an average of . However, when evaluating their approach in windy conditions, the speedup in running time is comparable to T* (as local transitions cannot be computed analytically and a computationally expensive rootfinding problem needs to be solved [23]), and the quality of paths remain higher (again, with no formal guarantees).
An alternative approach is to compare our work with the approach by Mittal et al. [16] that specifically accounted for efficient computation of paths in dynamic environments. However, the main objective of their approach is online motionplanning under ocean currents, and no importance was given to the quality of paths. When comparing T* with their approach on representative environments, the path quality obtained by T* was higher (lower execution times) by a factor of more than .
Vii Conclusions and Future Work
In this work, we present T*, a novel algorithmic framework for efficiently finding boundedsuboptimal solutions for timeoptimal motionplanning. This is done by minimizing the number of computations of timeoptimal transitions used by the system. When one cannot precompute the timeoptimal transitions in advance, this reduces the planning times by orders of magnitude compared to the stateoftheart.
Future work includes adapting our work for efficient replaning (e.g., when the wind changes while the system is in motion or dramatic payload changes during trajectory execution changing the system’s constraint). Here, we plan to adapt LPA* [11] to account for minimizing the number of transitions used.
Another natural extension is to account for settings when the approximation factor cannot be determined a priori by the user. Here, it is natural to use an anytime [8] approach. Instead of providing a fixed , the user would provide an upper bound for the algorithm’s running time. We suggest starting with an initially high value of the approximation factor to compute an initial solution quickly and then progressively decreases as the time permits while reusing transitions computed in earlier search episodes.
Appendix
To consider the setting where we need to account for wind currents, we detail the updated dynamics model and present two approaches to compute lower bounds on transitions costefficiently.
Viia Updated Model
We assume that there is a constant wind that changes the original system dynamics (Eq. 1) to
(8) 
Furthermore, we assume that regardless of the magnitude of the wind, the vehicle will move forward. It is ensured by the additional assumption that the wind magnitude is smaller than the minimum speed of the system , i.e.,
(9) 
ViiB Updated Lower Bounds
The wind component may significantly influence the turning capabilities (in the reference frame of the ground). The smallest turning radius is obtained when flying directly against the wind. We denote it by , the lower bound radius, and have that
(10) 
To this end, a lower bound on the true length of the path between two configurations and can be determined based on the length of Dubins path with the lower bound radius . Now, if this value is divided by an upper bound on the effective maximal speed in the reference frame of the ground, it provides a lower bound on the true cost (i.e., the travel time).
We suggest two lower bounds based on how is determined. The first approach assumes that . Namely, the effective maximal speed is the sum of the system’s maximum speed and the wind magnitude. Thus, the first lower bound is defined as
(11) 
The second lower bound considers the direction between the start and end configurations ( and , respectively) by computing the ground speed in the given direction . The direction is determined based on the configurations and as , where stands for the coordinates of the configuration . The ground speed vector can be expressed by the system’s aerial speed and wind as .
Following Eq. 9, the maximum ground speed occurs at the system’s maximum speed, i.e., . The angle between and can be written as Subsequently, the ground speed can be expressed using the cosine rule as Finally, the second lower bound is defined as
(12) 
Fig. 6 shows the average ratio between each lower bounds and the true cost as a function of the wind force. For both lower bounds, their estimation of the true cost becomes looser as the wind force increases. Notice that is more informative than because accounting for the direction enables reducing the upper bound on the ground speed. In addition, notice that both lower bounds reduce to the system’s minimumspeed Dubins path divided by the maximum speed in static environmental conditions. Thus, we used as lower bound for dynamic environmental conditions.
References
 [1] (2002) Curvatureconstrained shortest paths in a convex polygon. SIAM J. Comput. 31 (6), pp. 1814–1851. Cited by: §I.
 [2] (2000) Path planning using lazy PRM. In ICRA, Vol. 1, pp. 521–528. Cited by: §I.
 [3] (2016) A unifying formalism for shortest path problems with expensive edge evaluations via lazy bestfirst search over paths with edge selectors. In ICAPS, Vol. 26. Cited by: §I.
 [4] (1957) On curves of minimal length with a constraint on average curvature, and with prescribed initial and terminal positions and tangents. Am. J. Math. 79 (3), pp. 497–516. Cited by: §II.
 [5] (2017) On solution of the dubins touring problem. In ECMR, pp. 1–6. Cited by: §II.
 [6] (2009) Path planning for autonomous underwater vehicles in realistic oceanic current fields: application to gliders in the western mediterranean sea. J. Marit. Res. 6 (2), pp. 5–22. Cited by: §I.
 [7] (2018) The provable virtue of laziness in motion planning. In ICAPS, Vol. 28. Cited by: §I.
 [8] (2007) Anytime heuristic search. J. Artif. Intell. Res. 28, pp. 267–297. Cited by: §VII.
 [9] (1968) A formal basis for the heuristic determination of minimum cost paths. IEEE Trans. Syst. Man Cybern. 4 (2), pp. 100–107. Cited by: §IVA.
 [10] (2015) Lazy collision checking in asymptoticallyoptimal motion planning. In ICRA, pp. 2951–2957. Cited by: §I.
 [11] (2004) Lifelong planning A*. Artif. Intell. 155 (12), pp. 93–146. Cited by: §VII.
 [12] (2011) Toward robotic needle steering in lung biopsy: a tendonactuated approach. In Medical Imaging: ImageGuided Procedures, Vol. 7964, pp. 79641I. Cited by: §I.
 [13] (2021) Variablespeed traveling salesman problem for vehicles with curvature constrained trajectories. In IROS, pp. 4714–47194714–4719. External Links: Document Cited by: §II.
 [14] (2006) Planning algorithms. Cambridge University Press. External Links: Link Cited by: §I.
 [15] (2019) Generalized lazy search for robot motion planning: interleaving search and edge evaluation via eventbased toggles. In ICAPS, Vol. 29, pp. 745–753. Cited by: §I.
 [16] (2020) Rapid path planning for dubins vehicles under environmental currents. Robotics Auton. Syst. 134, pp. 103646. Cited by: §II, §VID, §VIE.
 [17] (1982) Studies in semiadmissible heuristics. IEEE Trans. Pattern Anal. Mach. Intell (4), pp. 392–399. Cited by: §I, §IVA, §IV, §VB.
 [18] (2019) Physical orienteering problem for unmanned aerial vehicle data collection planning in environments with obstacles. RAL 4 (3), pp. 3005–3012. Cited by: §II.
 [19] (2013) Robot motion planning with dynamics as hybrid search. In AAAI, Cited by: §II.
 [20] (2016) Planning for autonomous cars that leverage effects on human actions. In RSS, Vol. 2, pp. 1–9. Cited by: §I.
 [21] (2016) Asymptotically nearoptimal RRT for fast, highquality motion planning. IEEE Trans. Robotics 32 (3), pp. 473–483. Cited by: §I.
 [22] (2018) T: timeoptimal riskaware motion planning for curvatureconstrained vehicles. RAL 4 (1), pp. 33–40. Cited by: Fig. 1, §II, §III, §III, §IVB, §IVB, §IV, §VI.
 [23] (2009) Minimumtime path planning for unmanned aerial vehicles in steady uniform winds. J. Guid. Control Dyn. 32 (6), pp. 1736–1746. Cited by: §II, §VID, §VIE.
 [24] (2010) Near optimal path planning for vehicle with heading and curvature constraints. In WCICA, pp. 4514–4519. Cited by: §I.
 [25] (2019) Novel motion models for timeoptimal riskaware motion planning for variablespeed AUVs. In OCEANS MTS/IEEE, pp. 1–5. Cited by: §II, §VIE.
 [26] (2020) Tlite: a fast timerisk optimal motion planning algorithm for multispeed autonomous vehicles. In OCEANS MTS/IEEE, pp. 1–6. Cited by: §II.
 [27] (2016) Timeoptimal path planning for a kinematic car with variable speed. J. Guid. Control Dyn. 39 (10), pp. 2374–2390. Cited by: §II, §IVB, §VID.
 [28] (2011) Development of a lowcost agricultural remote sensing system based on an autonomous unmanned aerial vehicle (UAV). Biosystems Engineering 108 (2), pp. 174–190. Cited by: §I.
 [29] (2015) A survey on path planning for persistent autonomy of autonomous underwater vehicles. O.E. 110, pp. 303–313. Cited by: §I.